From 5946dc3eef405c539aabffe92718e6a3dad9c3f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 13:25:03 +0200 Subject: [PATCH 01/47] Add memory selection task to backend --- include/openPMD/Dataset.hpp | 6 +++ include/openPMD/IO/ADIOS/ADIOS2File.hpp | 2 + include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp | 15 +++++++ include/openPMD/IO/ADIOS/macros.hpp | 23 +++++++++++ include/openPMD/IO/IOTask.hpp | 1 + src/IO/ADIOS/ADIOS2File.cpp | 43 ++++++++++++++++++++ src/IO/ADIOS/ADIOS2IOHandler.cpp | 2 + src/IO/AbstractIOHandlerImpl.cpp | 24 +++++++++-- src/IO/HDF5/HDF5IOHandler.cpp | 6 +++ src/IO/JSON/JSONIOHandlerImpl.cpp | 7 ++++ 10 files changed, 125 insertions(+), 4 deletions(-) diff --git a/include/openPMD/Dataset.hpp b/include/openPMD/Dataset.hpp index e1f0058885..27195abb4d 100644 --- a/include/openPMD/Dataset.hpp +++ b/include/openPMD/Dataset.hpp @@ -34,6 +34,12 @@ namespace openPMD using Extent = std::vector; using Offset = std::vector; +struct MemorySelection +{ + Offset offset; + Extent extent; +}; + class Dataset { friend class RecordComponent; diff --git a/include/openPMD/IO/ADIOS/ADIOS2File.hpp b/include/openPMD/IO/ADIOS/ADIOS2File.hpp index d34cc8ebe5..0b7aa6f314 100644 --- a/include/openPMD/IO/ADIOS/ADIOS2File.hpp +++ b/include/openPMD/IO/ADIOS/ADIOS2File.hpp @@ -20,6 +20,7 @@ */ #pragma once +#include "openPMD/Dataset.hpp" #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp" #include "openPMD/IO/ADIOS/ADIOS2PreloadAttributes.hpp" #include "openPMD/IO/ADIOS/ADIOS2PreloadVariables.hpp" @@ -112,6 +113,7 @@ struct BufferedUniquePtrPut std::string name; Offset offset; Extent extent; + std::optional memorySelection; UniquePtrWithLambda data; Datatype dtype = Datatype::UNDEFINED; diff --git a/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp index 4316f5181f..c2185a0f96 100644 --- a/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp +++ b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp @@ -21,6 +21,7 @@ */ #pragma once +#include "openPMD/Dataset.hpp" #include "openPMD/Error.hpp" #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp" #include "openPMD/IO/ADIOS/ADIOS2FilePosition.hpp" @@ -509,6 +510,7 @@ class ADIOS2IOHandlerImpl adios2::Variable verifyDataset( Offset const &offset, Extent const &extent, + std::optional const &memorySelection, adios2::IO &IO, adios2::Engine &engine, std::string const &varName, @@ -622,6 +624,18 @@ class ADIOS2IOHandlerImpl var.SetSelection( {adios2::Dims(offset.begin(), offset.end()), adios2::Dims(extent.begin(), extent.end())}); + + if (memorySelection.has_value()) + { + var.SetMemorySelection( + {adios2::Dims( + memorySelection->offset.begin(), + memorySelection->offset.end()), + adios2::Dims( + memorySelection->extent.begin(), + memorySelection->extent.end())}); + } + return var; } @@ -629,6 +643,7 @@ class ADIOS2IOHandlerImpl { bool noGroupBased = false; bool blosc2bp5 = false; + bool memorySelection = false; } printedWarningsAlready; }; // ADIOS2IOHandlerImpl diff --git a/include/openPMD/IO/ADIOS/macros.hpp b/include/openPMD/IO/ADIOS/macros.hpp index 8195d36e8a..dd33af3b0b 100644 --- a/include/openPMD/IO/ADIOS/macros.hpp +++ b/include/openPMD/IO/ADIOS/macros.hpp @@ -46,6 +46,29 @@ #define openPMD_HAVE_ADIOS2_BP5 0 #endif +namespace openPMD +{ +namespace detail +{ + template + struct CanTheMemorySelectionBeReset + { + static constexpr bool value = false; + }; + + template + struct CanTheMemorySelectionBeReset< + Variable, + decltype(std::declval().SetMemorySelection())> + { + static constexpr bool value = true; + }; +} // namespace detail + +constexpr bool CanTheMemorySelectionBeReset = + detail::CanTheMemorySelectionBeReset>::value; +} // namespace openPMD + #else #define openPMD_HAS_ADIOS_2_8 0 diff --git a/include/openPMD/IO/IOTask.hpp b/include/openPMD/IO/IOTask.hpp index 25e0d6ad54..636140f04f 100644 --- a/include/openPMD/IO/IOTask.hpp +++ b/include/openPMD/IO/IOTask.hpp @@ -495,6 +495,7 @@ struct OPENPMDAPI_EXPORT Extent extent = {}; Offset offset = {}; + std::optional memorySelection = std::nullopt; Datatype dtype = Datatype::UNDEFINED; auxiliary::WriteBuffer data; }; diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp index 1d181033eb..997dcb537c 100644 --- a/src/IO/ADIOS/ADIOS2File.cpp +++ b/src/IO/ADIOS/ADIOS2File.cpp @@ -23,6 +23,7 @@ #include "openPMD/Error.hpp" #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp" #include "openPMD/IO/ADIOS/ADIOS2IOHandler.hpp" +#include "openPMD/IO/ADIOS/macros.hpp" #include "openPMD/IO/AbstractIOHandler.hpp" #include "openPMD/IterationEncoding.hpp" #include "openPMD/auxiliary/Environment.hpp" @@ -70,6 +71,7 @@ void DatasetReader::call( adios2::Variable var = impl->verifyDataset( bp.param.offset, bp.param.extent, + std::nullopt, IO, engine, bp.name, @@ -88,6 +90,12 @@ void DatasetReader::call( template inline constexpr bool always_false_v = false; +static constexpr char const *warningMemorySelection = + "[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."; + template void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp) { @@ -106,6 +114,7 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp) adios2::Variable var = ba.m_impl->verifyDataset( bp.param.offset, bp.param.extent, + bp.param.memorySelection, ba.m_IO, engine, bp.name, @@ -113,6 +122,19 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp) ba.variables()); engine.Put(var, ptr); + if (bp.param.memorySelection.has_value()) + { + if constexpr (openPMD::CanTheMemorySelectionBeReset) + { + var.SetMemorySelection(); + } + else if (!ba.m_impl->printedWarningsAlready.memorySelection) + { + std::cerr << warningMemorySelection << std::endl; + ba.m_impl->printedWarningsAlready.memorySelection = + true; + } + } } else if constexpr ( std::is_same_v< @@ -123,6 +145,14 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp) bput.name = std::move(bp.name); bput.offset = std::move(bp.param.offset); bput.extent = std::move(bp.param.extent); + bput.memorySelection = std::move(bp.param.memorySelection); + /* + * Note: Moving is required here since it's a unique_ptr. + * std::forward<>() would theoretically work, but it + * requires the type parameter and we don't have that + * inside the lambda. + * (ptr_type does not work for this case). + */ bput.data = arg.release(); bput.dtype = bp.param.dtype; ba.m_uniquePtrPuts.push_back(std::move(bput)); @@ -170,12 +200,25 @@ struct RunUniquePtrPut adios2::Variable var = ba.m_impl->verifyDataset( bufferedPut.offset, bufferedPut.extent, + bufferedPut.memorySelection, ba.m_IO, engine, bufferedPut.name, std::nullopt, ba.variables()); engine.Put(var, ptr); + if (bufferedPut.memorySelection.has_value()) + { + if constexpr (openPMD::CanTheMemorySelectionBeReset) + { + var.SetMemorySelection(); + } + else if (!ba.m_impl->printedWarningsAlready.memorySelection) + { + std::cerr << warningMemorySelection << std::endl; + ba.m_impl->printedWarningsAlready.memorySelection = true; + } + } } static constexpr char const *errorMsg = "RunUniquePtrPut"; diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp index 3f16bcf155..3abb6d8b54 100644 --- a/src/IO/ADIOS/ADIOS2IOHandler.cpp +++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp @@ -51,6 +51,7 @@ #include #include #include +#include #include #include #include @@ -1239,6 +1240,7 @@ namespace detail adios2::Variable variable = impl->verifyDataset( params.offset, params.extent, + std::nullopt, IO, engine, varName, diff --git a/src/IO/AbstractIOHandlerImpl.cpp b/src/IO/AbstractIOHandlerImpl.cpp index 4f93ff1a5b..fe5efc2d66 100644 --- a/src/IO/AbstractIOHandlerImpl.cpp +++ b/src/IO/AbstractIOHandlerImpl.cpp @@ -275,10 +275,26 @@ std::future AbstractIOHandlerImpl::flush() i.writable->parent, "->", i.writable, - "] WRITE_DATASET, offset=", - [¶meter]() { return vec_as_string(parameter.offset); }, - ", extent=", - [¶meter]() { return vec_as_string(parameter.extent); }); + "] WRITE_DATASET: ", + [&]() { + std::stringstream stream; + stream << "offset: " << vec_as_string(parameter.offset) + << " extent: " << vec_as_string(parameter.extent) + << " mem-selection: "; + if (parameter.memorySelection.has_value()) + { + stream << vec_as_string( + parameter.memorySelection->offset) + << "--" + << vec_as_string( + parameter.memorySelection->extent); + } + else + { + stream << "NONE"; + } + return stream.str(); + }); writeDataset(i.writable, parameter); break; } diff --git a/src/IO/HDF5/HDF5IOHandler.cpp b/src/IO/HDF5/HDF5IOHandler.cpp index d859ccc122..f8c1299a10 100644 --- a/src/IO/HDF5/HDF5IOHandler.cpp +++ b/src/IO/HDF5/HDF5IOHandler.cpp @@ -1896,6 +1896,12 @@ void HDF5IOHandlerImpl::writeDataset( "[HDF5] Writing into a dataset in a file opened as read only is " "not possible."); + if (parameters.memorySelection.has_value()) + { + throw error::OperationUnsupportedInBackend( + "HDF5", + "Non-contiguous memory selections not supported in HDF5 backend."); + } File file = requireFile("writeDataset", writable, /* checkParent = */ true); herr_t status; diff --git a/src/IO/JSON/JSONIOHandlerImpl.cpp b/src/IO/JSON/JSONIOHandlerImpl.cpp index 9308af2e62..90f547edda 100644 --- a/src/IO/JSON/JSONIOHandlerImpl.cpp +++ b/src/IO/JSON/JSONIOHandlerImpl.cpp @@ -1146,6 +1146,13 @@ void JSONIOHandlerImpl::writeDataset( access::write(m_handler->m_backendAccess), "[JSON] Cannot write data in read-only mode."); + if (parameters.memorySelection.has_value()) + { + throw error::OperationUnsupportedInBackend( + "JSON", + "Non-contiguous memory selections not supported in JSON backend."); + } + auto pos = setAndGetFilePosition(writable); auto file = refreshFileFromParent(writable); auto &j = obtainJsonContents(writable); From 30eadbf634a1eb5ad64d55941d5b555e94d6459e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 13:34:49 +0200 Subject: [PATCH 02/47] Add future helper --- CMakeLists.txt | 1 + include/openPMD/auxiliary/Future.hpp | 23 ++++++++++++ src/auxiliary/Future.cpp | 53 ++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+) create mode 100644 include/openPMD/auxiliary/Future.hpp create mode 100644 src/auxiliary/Future.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index f2dcc98f82..f24ce5d822 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -411,6 +411,7 @@ set(CORE_SOURCE src/version.cpp src/auxiliary/Date.cpp src/auxiliary/Filesystem.cpp + src/auxiliary/Future.cpp src/auxiliary/JSON.cpp src/auxiliary/JSONMatcher.cpp src/auxiliary/Memory.cpp diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp new file mode 100644 index 0000000000..d40f7372fb --- /dev/null +++ b/include/openPMD/auxiliary/Future.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "openPMD/auxiliary/TypeTraits.hpp" + +#include + +namespace openPMD::auxiliary +{ +template +class DeferredComputation +{ + using task_type = std::function; + task_type m_task; + bool m_valid = false; + +public: + DeferredComputation(task_type); + + auto get() -> T; + + [[nodiscard]] auto valid() const noexcept -> bool; +}; +} // namespace openPMD::auxiliary diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp new file mode 100644 index 0000000000..d55ab3f2d7 --- /dev/null +++ b/src/auxiliary/Future.cpp @@ -0,0 +1,53 @@ +#include "openPMD/auxiliary/Future.hpp" +#include "openPMD/RecordComponent.hpp" + +#include +#include +#include + +// comment + +#include "openPMD/DatatypeMacros.hpp" + +namespace openPMD::auxiliary +{ + +template +DeferredComputation::DeferredComputation(task_type task) + : m_task([wrapped_task = std::move(task), this]() { + if (!this->m_valid) + { + throw std::runtime_error( + "[DeferredComputation] No valid state. Probably already " + "computed."); + } + this->m_valid = false; + return std::move(wrapped_task)(); + }) + , m_valid(true) +{} + +template +auto DeferredComputation::get() -> T +{ + return m_task(); +} + +template +auto DeferredComputation::valid() const noexcept -> bool +{ + return m_valid; +} + +template class DeferredComputation; +template class DeferredComputation; +// clang-format off +#define INSTANTIATE_FUTURE(dtype) \ + /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ + template class DeferredComputation>; +OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_FUTURE) +#undef INSTANTIATE_FUTURE +// clang-format on +} // namespace openPMD::auxiliary + +#include "openPMD/UndefDatatypeMacros.hpp" From b239cca53b30f03205b035481b649962c1870ad2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 13:36:00 +0200 Subject: [PATCH 03/47] Fixes for UniquePtr.hpp --- include/openPMD/auxiliary/UniquePtr.hpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/openPMD/auxiliary/UniquePtr.hpp b/include/openPMD/auxiliary/UniquePtr.hpp index 87f3261b45..ee17794d3e 100644 --- a/include/openPMD/auxiliary/UniquePtr.hpp +++ b/include/openPMD/auxiliary/UniquePtr.hpp @@ -176,10 +176,11 @@ template UniquePtrWithLambda UniquePtrWithLambda::static_cast_() && { using other_type = std::remove_extent_t; + auto original_ptr = this->release(); return UniquePtrWithLambda{ - static_cast(this->release()), - [deleter = std::move(this->get_deleter())](other_type *ptr) { - deleter(static_cast(ptr)); + static_cast(original_ptr), + [deleter = std::move(this->get_deleter()), original_ptr](other_type *) { + deleter(original_ptr); }}; } } // namespace openPMD From 8531a8dfe54f2580f179ac0fc1dda9cd1d2436f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 13:49:36 +0200 Subject: [PATCH 04/47] Main implementation of LoadStoreChunk.hpp --- CMakeLists.txt | 1 + include/openPMD/LoadStoreChunk.hpp | 298 ++++++++++++++++++++++ include/openPMD/LoadStoreChunk.tpp | 64 +++++ include/openPMD/RecordComponent.hpp | 50 +++- include/openPMD/RecordComponent.tpp | 56 +++++ src/LoadStoreChunk.cpp | 368 ++++++++++++++++++++++++++++ src/RecordComponent.cpp | 190 +++++++++++++- src/auxiliary/Future.cpp | 2 +- src/auxiliary/UniquePtr.cpp | 2 +- 9 files changed, 1017 insertions(+), 14 deletions(-) create mode 100644 include/openPMD/LoadStoreChunk.hpp create mode 100644 include/openPMD/LoadStoreChunk.tpp create mode 100644 src/LoadStoreChunk.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index f24ce5d822..004a20de1e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -400,6 +400,7 @@ set(CORE_SOURCE src/Format.cpp src/Iteration.cpp src/IterationEncoding.cpp + src/LoadStoreChunk.cpp src/Mesh.cpp src/ParticlePatches.cpp src/ParticleSpecies.cpp diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp new file mode 100644 index 0000000000..8d6dee401f --- /dev/null +++ b/include/openPMD/LoadStoreChunk.hpp @@ -0,0 +1,298 @@ +#pragma once + +#include "openPMD/Dataset.hpp" +#include "openPMD/auxiliary/Future.hpp" +#include "openPMD/auxiliary/ShareRawInternal.hpp" +#include "openPMD/auxiliary/UniquePtr.hpp" + +// comment to prevent this include from being moved by clang-format +#include "openPMD/DatatypeMacros.hpp" + +#include +#include +#include +#include + +namespace openPMD +{ +class RecordComponent; +template +class ConfigureStoreChunkFromBuffer; +template +class ConfigureLoadStoreFromBuffer; +template +class DynamicMemoryView; + +namespace internal +{ + struct LoadStoreConfig + { + Offset offset; + Extent extent; + }; + struct LoadStoreConfigWithBuffer + { + Offset offset; + Extent extent; + std::optional memorySelection; + }; + +} // namespace internal + +namespace auxiliary::detail +{ +#define OPENPMD_ENUMERATE_TYPES(type) , std::shared_ptr + using shared_ptr_dataset_types = auxiliary::detail::variant_tail_t< + auxiliary::detail::bottom OPENPMD_FOREACH_DATASET_DATATYPE( + OPENPMD_ENUMERATE_TYPES)>; +#undef OPENPMD_ENUMERATE_TYPES +} // namespace auxiliary::detail + +namespace compose +{ + template + class ConfigureLoadStore; + template + class ConfigureLoadStoreFromBuffer; +} // namespace compose + +enum class EnqueuePolicy +{ + Defer, + Immediate +}; + +namespace core +{ + /* + * Actual data members of `ConfigureLoadStore<>` and methods that don't + * depend on the ChildClass template parameter. By extracting the members to + * this struct, we can pass them around between different instances of the + * class template. Numbers of method instantiations can be reduced. + */ + class ConfigureLoadStore + { + template + friend class compose::ConfigureLoadStore; + template + friend class compose::ConfigureLoadStoreFromBuffer; + + protected: + ConfigureLoadStore(RecordComponent &); + RecordComponent &m_rc; + + std::optional m_offset; + std::optional m_extent; + + [[nodiscard]] auto dim() const -> uint8_t; + auto storeChunkConfig() -> internal::LoadStoreConfig; + + public: + auto getOffset() -> Offset const &; + auto getExtent() -> Extent const &; + /* + * If the type is non-const, then the return type should be + * ConfigureLoadStoreFromBuffer<>, ... + */ + template + struct shared_ptr_return_type_impl + { + using type = ConfigureLoadStoreFromBuffer>; + }; + /* + * ..., but if it is a const type, Load operations make no sense, so the + * return type should be ConfigureStoreChunkFromBuffer<>. + */ + template + struct shared_ptr_return_type_impl + { + using type = + ConfigureStoreChunkFromBuffer>; + }; + + template + using shared_ptr_return_type = + typename shared_ptr_return_type_impl>::type; + + /* + * As loading into unique pointer types makes no sense, the case is + * simpler for unique pointers. Just remove the array extents here. + */ + template + using unique_ptr_return_type = ConfigureStoreChunkFromBuffer< + UniquePtrWithLambda>>; + + // @todo rvalue references..? + template + auto withSharedPtr(std::shared_ptr) -> shared_ptr_return_type; + template + auto withUniquePtr(UniquePtrWithLambda) -> unique_ptr_return_type; + template + auto withUniquePtr(std::unique_ptr) + -> unique_ptr_return_type; + template + auto withRawPtr(T *data) -> shared_ptr_return_type; + template + auto withContiguousContainer(T_ContiguousContainer &data) + -> std::enable_if_t< + auxiliary::IsContiguousContainer_v, + shared_ptr_return_type< + typename T_ContiguousContainer::value_type>>; + + template + [[nodiscard]] auto enqueueStore() -> DynamicMemoryView; + // definition for this one is in RecordComponent.tpp since it needs the + // definition of class RecordComponent. + template + [[nodiscard]] auto enqueueStore(F &&createBuffer) + -> DynamicMemoryView; + + template + [[nodiscard]] auto enqueueLoad() + -> auxiliary::DeferredComputation>; + + template + [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr; + + [[nodiscard]] auto enqueueLoadVariant() + -> auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types>; + + [[nodiscard]] auto loadVariant(EnqueuePolicy) + -> auxiliary::detail::shared_ptr_dataset_types; + }; + + template + class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore + { + public: + Ptr_Type m_buffer; + std::optional m_mem_select; + + ConfigureStoreChunkFromBuffer(Ptr_Type buffer, ConfigureLoadStore &&); + + auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; + + auto enqueueStore() -> auxiliary::DeferredComputation; + + auto store(EnqueuePolicy) -> void; + + /** This intentionally shadows the parent class's enqueueLoad methods in + * order to show a compile error when using enqueueLoad() on an object + * of this class. The parent method can still be accessed through + * as_parent() if needed. + */ + template + auto enqueueLoad() + { + static_assert( + auxiliary::dependent_false_v, + "Cannot load chunk data into a buffer that is const or a " + "unique_ptr."); + } + + template + auto load(EnqueuePolicy) + { + static_assert( + auxiliary::dependent_false_v, + "Cannot load chunk data into a buffer that is const or a " + "unique_ptr."); + } + }; + + template + class ConfigureLoadStoreFromBuffer + : public ConfigureStoreChunkFromBuffer + { + public: + using ConfigureStoreChunkFromBuffer< + Ptr_Type>::ConfigureStoreChunkFromBuffer; + + auto enqueueLoad() -> auxiliary::DeferredComputation; + + auto load(EnqueuePolicy) -> void; + }; +} // namespace core + +namespace compose +{ + /** Basic configuration for a Load/Store operation. + * + * @tparam ChildClass CRT pattern. + * The purpose is that in child classes `return *this` should return + * an instance of the child class, not of ConfigureLoadStore. + * Instantiate with void when using without subclass. + */ + template + class ConfigureLoadStore + { + public: + auto offset(Offset) -> ChildClass &; + auto extent(Extent) -> ChildClass &; + }; + + /** Configuration for a Store operation with a buffer type. + * + * This class does intentionally not support Load operations since there are + * pointer types (const pointers, unique pointers) where Load operations + * make no sense. See the \ref ConfigureLoadStoreFromBuffer class template + * for both Load/Store operations. + * + * @tparam Ptr_Type The type of pointer used internally. + * @tparam ChildClass CRT pattern. + * The purpose is that in child classes `return *this` should return + * an instance of the child class, not of + * ConfigureStoreChunkFromBuffer. Instantiate with void when using without + * subclass. + */ + template + class ConfigureStoreChunkFromBuffer + { + public: + auto memorySelection(MemorySelection) -> ChildClass &; + }; +} // namespace compose + +class ConfigureLoadStore + : public core::ConfigureLoadStore + , public compose::ConfigureLoadStore +{ + friend class RecordComponent; + friend class core::ConfigureLoadStore; + + ConfigureLoadStore(RecordComponent &rc); + ConfigureLoadStore(core::ConfigureLoadStore &&); +}; + +template +class ConfigureStoreChunkFromBuffer + : public core::ConfigureStoreChunkFromBuffer + , public compose::ConfigureLoadStore< + ConfigureStoreChunkFromBuffer> + , public compose::ConfigureStoreChunkFromBuffer< + ConfigureStoreChunkFromBuffer> +{ + friend class core::ConfigureLoadStore; + + using core::ConfigureStoreChunkFromBuffer< + Ptr_Type>::ConfigureStoreChunkFromBuffer; +}; + +template +class ConfigureLoadStoreFromBuffer + : public core::ConfigureLoadStoreFromBuffer + , public compose::ConfigureLoadStore> + , public compose::ConfigureStoreChunkFromBuffer< + ConfigureLoadStoreFromBuffer> +{ + friend class ConfigureLoadStoreCore; + + using core::ConfigureLoadStoreFromBuffer< + Ptr_Type>::ConfigureLoadStoreFromBuffer; +}; +} // namespace openPMD + +#include "openPMD/UndefDatatypeMacros.hpp" +// comment to prevent these includes from being moved by clang-format +#include "openPMD/LoadStoreChunk.tpp" diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp new file mode 100644 index 0000000000..c3c104cebd --- /dev/null +++ b/include/openPMD/LoadStoreChunk.tpp @@ -0,0 +1,64 @@ +#pragma once + +#include "openPMD/LoadStoreChunk.hpp" + +namespace openPMD::core +{ +template +auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) + -> shared_ptr_return_type +{ + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return shared_ptr_return_type( + std::static_pointer_cast>(std::move(data)), + {std::move(*this)}); +} +template +auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) + -> unique_ptr_return_type + +{ + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return unique_ptr_return_type( + std::move(data).template static_cast_>(), + {std::move(*this)}); +} +template +auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type +{ + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return shared_ptr_return_type( + auxiliary::shareRaw(data), {std::move(*this)}); +} + +template +auto ConfigureLoadStore::withUniquePtr(std::unique_ptr data) + -> unique_ptr_return_type +{ + return withUniquePtr(UniquePtrWithLambda(std::move(data))); +} +template +auto ConfigureLoadStore::withContiguousContainer(T_ContiguousContainer &data) + -> std::enable_if_t< + auxiliary::IsContiguousContainer_v, + shared_ptr_return_type> +{ + if (!m_extent.has_value() && dim() == 1) + { + m_extent = Extent{data.size()}; + } + return withRawPtr(data.data()); +} +} // namespace openPMD::core diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index d06b4213f4..3c74d2a3b5 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -22,15 +22,13 @@ #include "openPMD/Dataset.hpp" #include "openPMD/Datatype.hpp" +#include "openPMD/LoadStoreChunk.hpp" #include "openPMD/auxiliary/ShareRaw.hpp" #include "openPMD/auxiliary/TypeTraits.hpp" #include "openPMD/auxiliary/UniquePtr.hpp" #include "openPMD/backend/Attributable.hpp" #include "openPMD/backend/BaseRecordComponent.hpp" -// comment to prevent this include from being moved by clang-format -#include "openPMD/DatatypeMacros.hpp" - #include #include #include @@ -107,6 +105,17 @@ namespace internal class BaseRecordData; } // namespace internal +namespace core +{ + class ConfigureLoadStore; + template + class ConfigureLoadStoreFromBuffer; + template + class ConfigureStoreChunkFromBuffer; + struct VisitorEnqueueLoadVariant; + struct VisitorLoadVariant; +} // namespace core + template class BaseRecord; @@ -128,6 +137,13 @@ class RecordComponent : public BaseRecordComponent friend class MeshRecordComponent; template friend T &internal::makeOwning(T &self, Series); + friend class core::ConfigureLoadStore; + template + friend class core::ConfigureLoadStoreFromBuffer; + template + friend class core::ConfigureStoreChunkFromBuffer; + friend struct core::VisitorEnqueueLoadVariant; + friend struct core::VisitorLoadVariant; public: enum class Allocation @@ -214,6 +230,8 @@ class RecordComponent : public BaseRecordComponent */ bool empty() const; + ConfigureLoadStore prepareLoadStore(); + /** Load and allocate a chunk of data * * Set offset to {0u} and extent to {-1u} for full selection. @@ -224,11 +242,8 @@ class RecordComponent : public BaseRecordComponent template std::shared_ptr loadChunk(Offset = {0u}, Extent = {-1u}); -#define OPENPMD_ENUMERATE_TYPES(type) , std::shared_ptr - using shared_ptr_dataset_types = auxiliary::detail::variant_tail_t< - auxiliary::detail::bottom OPENPMD_FOREACH_DATASET_DATATYPE( - OPENPMD_ENUMERATE_TYPES)>; -#undef OPENPMD_ENUMERATE_TYPES + using shared_ptr_dataset_types = + auxiliary::detail::shared_ptr_dataset_types; /** std::variant-based version of allocating loadChunk(Offset, Extent) * @@ -500,6 +515,23 @@ class RecordComponent : public BaseRecordComponent void storeChunk( auxiliary::WriteBuffer buffer, Datatype datatype, Offset o, Extent e); + void storeChunk_impl( + auxiliary::WriteBuffer buffer, + Datatype datatype, + internal::LoadStoreConfigWithBuffer); + + template + DynamicMemoryView storeChunkSpan_impl(internal::LoadStoreConfig); + template + DynamicMemoryView storeChunkSpanCreateBuffer_impl( + internal::LoadStoreConfig, F &&createBuffer); + + template + void + loadChunk_impl(std::shared_ptr, internal::LoadStoreConfigWithBuffer); + template + std::shared_ptr loadChunkAllocate_impl(internal::LoadStoreConfig); + // clang-format off OPENPMD_protected // clang-format on @@ -564,6 +596,4 @@ namespace internal } // namespace openPMD -#include "openPMD/UndefDatatypeMacros.hpp" -// comment to prevent these includes from being moved by clang-format #include "RecordComponent.tpp" diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp index b796ab1a93..bf1d6b7bd6 100644 --- a/include/openPMD/RecordComponent.tpp +++ b/include/openPMD/RecordComponent.tpp @@ -158,6 +158,62 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer) return DynamicMemoryView{std::move(getBufferView), size, *this}; } +template +inline DynamicMemoryView RecordComponent::storeChunkSpanCreateBuffer_impl( + internal::LoadStoreConfig cfg, F &&createBuffer) +{ + auto [o, e] = std::move(cfg); + verifyChunk(o, e); + + /* + * The openPMD backend might not yet know about this dataset. + * Flush the openPMD hierarchy to the backend without flushing any actual + * data yet. + */ + seriesFlush_impl( + {FlushLevel::SkeletonOnly}); + + size_t size = 1; + for (auto ext : e) + { + size *= ext; + } + /* + * Flushing the skeleton does not create datasets, + * so we might need to do it now. + */ + if (!written()) + { + auto &rc = get(); + if (!rc.m_dataset.has_value()) + { + throw error::WrongAPIUsage( + "[RecordComponent] Must specify dataset type and extent before " + "using storeChunk() (see RecordComponent::resetDataset())."); + } + Parameter dCreate(rc.m_dataset.value()); + dCreate.name = rc->m_writable.ownKeyWithinParent; + IOHandler()->enqueue(IOTask(this, dCreate)); + } + Parameter getBufferView; + getBufferView.offset = o; + getBufferView.extent = e; + getBufferView.dtype = getDatatype(); + IOHandler()->enqueue(IOTask(this, getBufferView)); + IOHandler()->flush(internal::defaultFlushParams); + auto &out = *getBufferView.out; + if (!out.backendManagedBuffer) + { + // note that data might have either + // type shared_ptr or shared_ptr + auto data = std::forward(createBuffer)(size); + out.ptr = static_cast(data.get()); + storeChunk(std::move(data), std::move(o), std::move(e)); + } + setDirtyRecursive(true); + return DynamicMemoryView{std::move(getBufferView), size, *this}; +} + namespace detail { template diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp new file mode 100644 index 0000000000..526c01a3d9 --- /dev/null +++ b/src/LoadStoreChunk.cpp @@ -0,0 +1,368 @@ + + +#include "openPMD/LoadStoreChunk.hpp" +#include "openPMD/Datatype.hpp" +#include "openPMD/RecordComponent.hpp" +#include "openPMD/Span.hpp" +#include "openPMD/auxiliary/Memory.hpp" +#include "openPMD/auxiliary/ShareRawInternal.hpp" +#include "openPMD/auxiliary/TypeTraits.hpp" +#include "openPMD/auxiliary/UniquePtr.hpp" + +// comment to keep clang-format from reordering +#include "openPMD/DatatypeMacros.hpp" + +#include +#include +#include +#include + +namespace openPMD +{ +namespace +{ + template + auto asWriteBuffer(std::shared_ptr &&ptr) -> auxiliary::WriteBuffer + { + /* std::static_pointer_cast correctly reference-counts the pointer */ + return auxiliary::WriteBuffer( + std::static_pointer_cast(std::move(ptr))); + } + template + auto asWriteBuffer(UniquePtrWithLambda &&ptr) -> auxiliary::WriteBuffer + { + return auxiliary::WriteBuffer( + std::move(ptr).template static_cast_()); + } + + /* + * There is no backend support currently for const unique pointers. + * We support these mostly for providing a clean API to users that have such + * pointers and want to store from them, but there will be no + * backend-specific optimizations for such buffers as there are for + * non-const unique pointers. + */ + template + auto asWriteBuffer(UniquePtrWithLambda &&ptr) + -> auxiliary::WriteBuffer + { + auto raw_ptr = ptr.release(); + return asWriteBuffer( + std::shared_ptr{ + raw_ptr, + [deleter = std::move(ptr.get_deleter())]( + auto const *delete_me) { deleter(delete_me); }}); + } +} // namespace + +namespace core +{ + ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) : m_rc(rc) + {} + + auto ConfigureLoadStore::dim() const -> uint8_t + { + return m_rc.getDimensionality(); + } + + auto ConfigureLoadStore::storeChunkConfig() -> internal::LoadStoreConfig + { + return internal::LoadStoreConfig{getOffset(), getExtent()}; + } + + auto ConfigureLoadStore::getOffset() -> Offset const & + { + if (!m_offset.has_value()) + { + if (m_rc.joinedDimension().has_value()) + { + m_offset = std::make_optional(); + } + else + { + m_offset = std::make_optional(dim(), 0); + } + } + return *m_offset; + } + + auto ConfigureLoadStore::getExtent() -> Extent const & + { + if (!m_extent.has_value()) + { + m_extent = std::make_optional(m_rc.getExtent()); + if (m_offset.has_value()) + { + auto it_o = m_offset->begin(); + auto end_o = m_offset->end(); + auto it_e = m_extent->begin(); + auto end_e = m_extent->end(); + for (; it_o != end_o && it_e != end_e; ++it_e, ++it_o) + { + *it_e -= *it_o; + } + } + } + return *m_extent; + } + + template + auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView + { + return m_rc.storeChunkSpan_impl(storeChunkConfig()); + } + + template + auto ConfigureLoadStore::enqueueLoad() + -> auxiliary::DeferredComputation> + { + auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); + return auxiliary::DeferredComputation>( + [res_lambda = std::move(res), rc = m_rc]() mutable { + rc.seriesFlush(); + return res_lambda; + }); + } + + template + auto ConfigureLoadStore::load(EnqueuePolicy ep) -> std::shared_ptr + { + auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); + switch (ep) + { + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + m_rc.seriesFlush(); + break; + } + return res; + } + + struct VisitorEnqueueLoadVariant + { + template + static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) + -> auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types> + { + auto res = rc.loadChunkAllocate_impl(std::move(cfg)); + return auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types>( + + [res_lambda = std::move(res), rc_lambda = rc]() mutable + -> auxiliary::detail::shared_ptr_dataset_types { + std::cout << "Flushing Series from Future" << std::endl; + rc_lambda.seriesFlush(); + std::cout << "Flushed Series from Future" << std::endl; + return res_lambda; + }); + } + }; + + auto ConfigureLoadStore::enqueueLoadVariant() + -> auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types> + { + return m_rc.visit(this->storeChunkConfig()); + } + + struct VisitorLoadVariant + { + template + static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) + -> auxiliary::detail::shared_ptr_dataset_types + { + return rc.loadChunkAllocate_impl(std::move(cfg)); + } + }; + + auto ConfigureLoadStore::loadVariant(EnqueuePolicy ep) + -> auxiliary::detail::shared_ptr_dataset_types + { + auto res = m_rc.visit(this->storeChunkConfig()); + switch (ep) + { + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + m_rc.seriesFlush(); + break; + } + return res; + } + + template + ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( + Ptr_Type buffer, ConfigureLoadStore &&core) + : ConfigureLoadStore(std::move(core)), m_buffer(std::move(buffer)) + {} + + template + auto ConfigureStoreChunkFromBuffer::storeChunkConfig() + -> internal::LoadStoreConfigWithBuffer + { + return internal::LoadStoreConfigWithBuffer{ + this->getOffset(), this->getExtent(), m_mem_select}; + } + + template + auto ConfigureStoreChunkFromBuffer::enqueueStore() + -> auxiliary::DeferredComputation + { + this->m_rc.storeChunk_impl( + asWriteBuffer(std::move(m_buffer)), + determineDatatype>(), + storeChunkConfig()); + return auxiliary::DeferredComputation( + [rc_lambda = m_rc]() mutable -> void { rc_lambda.seriesFlush(); }); + } + + template + auto ConfigureStoreChunkFromBuffer::store(EnqueuePolicy ep) + -> void + { + this->m_rc.storeChunk_impl( + asWriteBuffer(std::move(m_buffer)), + determineDatatype>(), + storeChunkConfig()); + switch (ep) + { + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + m_rc.seriesFlush(); + break; + } + } + + template + auto ConfigureLoadStoreFromBuffer::enqueueLoad() + -> auxiliary::DeferredComputation + { + static_assert( + std::is_same_v< + Ptr_Type, + std::shared_ptr< + std::remove_cv_t>>, + "ConfigureLoadStoreFromBuffer must be instantiated with a " + "non-const " + "shared_ptr type."); + this->m_rc.loadChunk_impl( + std::move(this->m_buffer), this->storeChunkConfig()); + return auxiliary::DeferredComputation( + [rc_lambda = this->m_rc]() mutable -> void { + rc_lambda.seriesFlush(); + }); + } + + template + auto ConfigureLoadStoreFromBuffer::load(EnqueuePolicy ep) -> void + { + this->m_rc.loadChunk_impl( + std::move(this->m_buffer), this->storeChunkConfig()); + switch (ep) + { + + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + this->m_rc.seriesFlush(); + break; + } + } +} // namespace core + +namespace compose +{ + template + auto ConfigureLoadStore::extent(Extent extent) -> ChildClass & + { + static_cast(this)->m_extent = + std::make_optional(std::move(extent)); + return *static_cast(this); + } + + template + auto ConfigureLoadStore::offset(Offset offset) -> ChildClass & + { + static_cast(this)->m_offset = + std::make_optional(std::move(offset)); + return *static_cast(this); + } + + template + auto ConfigureStoreChunkFromBuffer::memorySelection( + MemorySelection sel) -> ChildClass & + { + static_cast(this)->m_mem_select = + std::make_optional(std::move(sel)); + return *static_cast(this); + } +} // namespace compose + +template class compose::ConfigureLoadStore; + +/* clang-format would destroy the NOLINT comments */ +// clang-format off +#define INSTANTIATE_METHOD_TEMPLATES(dtype) \ + template auto core::ConfigureLoadStore::enqueueStore() \ + -> DynamicMemoryView; \ + template auto core::ConfigureLoadStore::enqueueLoad() \ + /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ + -> auxiliary::DeferredComputation>; \ + template auto core::ConfigureLoadStore::load(EnqueuePolicy) \ + ->std::shared_ptr; +// clang-format on + +OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_METHOD_TEMPLATES) + +#undef INSTANTIATE_METHOD_TEMPLATES + +/* clang-format would destroy the NOLINT comments */ +// clang-format off +#define INSTANTIATE_HALF(pointer_type) \ + template class ConfigureStoreChunkFromBuffer; \ + template class core::ConfigureStoreChunkFromBuffer; \ + template class compose::ConfigureLoadStore< \ + /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ + ConfigureStoreChunkFromBuffer>; \ + template class compose::ConfigureStoreChunkFromBuffer< \ + /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ + ConfigureStoreChunkFromBuffer>; +// clang-format on + +/* clang-format would destroy the NOLINT comments */ +// clang-format off +#define INSTANTIATE_FULL(pointer_type) \ + INSTANTIATE_HALF(pointer_type) \ + template class ConfigureLoadStoreFromBuffer; \ + template class core::ConfigureLoadStoreFromBuffer; \ + template class compose::ConfigureLoadStore< \ + /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ + ConfigureLoadStoreFromBuffer>; \ + template class compose::ConfigureStoreChunkFromBuffer< \ + /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ + ConfigureLoadStoreFromBuffer>; +// clang-format on + +#define INSTANTIATE_STORE_CHUNK_FROM_BUFFER(dtype) \ + INSTANTIATE_FULL(std::shared_ptr) \ + INSTANTIATE_HALF(std::shared_ptr) \ + INSTANTIATE_HALF(UniquePtrWithLambda) +// /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ + +OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) + +#undef INSTANTIATE_STORE_CHUNK_FROM_BUFFER +#undef INSTANTIATE_METHOD_TEMPLATES +#undef INSTANTIATE_FULL +#undef INSTANTIATE_HALF + +ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) + : core::ConfigureLoadStore{rc} +{} +ConfigureLoadStore::ConfigureLoadStore(core::ConfigureLoadStore &&core) + : core::ConfigureLoadStore{std::move(core)} +{} +} // namespace openPMD diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index fbf2ad0d88..2fea07fa67 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -21,6 +21,7 @@ #include "openPMD/RecordComponent.hpp" #include "openPMD/Dataset.hpp" #include "openPMD/DatatypeHelpers.hpp" +#include "openPMD/DatatypeMacros.hpp" #include "openPMD/Error.hpp" #include "openPMD/IO/Format.hpp" #include "openPMD/Series.hpp" @@ -189,6 +190,72 @@ auto resource(T &t) -> attribute_types & return t.template resource(); } +ConfigureLoadStore RecordComponent::prepareLoadStore() +{ + return ConfigureLoadStore{*this}; +} + +namespace +{ +#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) || \ + (defined(__apple_build_version__) && __clang_major__ < 14) + template + auto createSpanBufferFallback(size_t size) -> std::shared_ptr + { + return std::shared_ptr{new T[size], [](auto *ptr) { delete[] ptr; }}; + } +#else + template + auto createSpanBufferFallback(size_t size) -> std::shared_ptr + { + return std::shared_ptr{new T[size]}; + } +#endif +} // namespace + +template +DynamicMemoryView +RecordComponent::storeChunkSpan_impl(internal::LoadStoreConfig cfg) +{ + return storeChunkSpanCreateBuffer_impl( + std::move(cfg), &createSpanBufferFallback); +} + +template +std::shared_ptr +RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg) +{ + using T = std::remove_extent_t; + // static_assert(!std::is_same_v, "EVIL"); + auto [o, e] = std::move(cfg); + + size_t numPoints = 1; + for (auto val : e) + { + numPoints *= val; + } + +#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) || \ + (defined(__apple_build_version__) && __clang_major__ < 14) + auto newData = std::shared_ptr( + new T[numPoints], [](T *p) { delete[] p; }); + prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .withSharedPtr(newData) + .load(EnqueuePolicy::Defer); + return newData; +#else + auto newData = std::shared_ptr(new T[numPoints]); + prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .withSharedPtr(newData) + .load(EnqueuePolicy::Defer); + return std::static_pointer_cast(std::move(newData)); +#endif +} + RecordComponent::RecordComponent() : BaseRecordComponent(NoInit()) { setData(std::make_shared()); @@ -648,6 +715,25 @@ void RecordComponent::storeChunk( rc.push_chunk(IOTask(this, std::move(dWrite))); } +void RecordComponent::storeChunk_impl( + auxiliary::WriteBuffer buffer, + Datatype dtype, + internal::LoadStoreConfigWithBuffer cfg) +{ + auto [o, e, memorySelection] = std::move(cfg); + verifyChunk(dtype, o, e); + + Parameter dWrite; + dWrite.offset = std::move(o); + dWrite.extent = std::move(e); + dWrite.memorySelection = memorySelection; + dWrite.dtype = dtype; + /* std::static_pointer_cast correctly reference-counts the pointer */ + dWrite.data = std::move(buffer); + auto &rc = get(); + rc.push_chunk(IOTask(this, std::move(dWrite))); +} + void RecordComponent::verifyChunk( Datatype dtype, Offset const &o, Extent const &e) const { @@ -822,6 +908,100 @@ namespace detail }; } // namespace detail +template +void RecordComponent::loadChunk_impl( + std::shared_ptr data, + internal::LoadStoreConfigWithBuffer cfg) +{ + if (cfg.memorySelection.has_value()) + { + throw error::WrongAPIUsage( + "Unsupported: Memory selections in chunk loading."); + } + using T = std::remove_cv_t>; + Datatype dtype = determineDatatype(data); + /* + * For constant components, we implement type conversion, so there is + * a separate check further below. + * This is especially useful for the short-attribute representation in the + * JSON/TOML backends as they might implicitly turn a LONG into an INT in a + * constant component. The frontend needs to catch such edge cases. + * Ref. `if (constant())` branch. + */ + if (dtype != getDatatype() && !constant()) + if (!isSameInteger(getDatatype()) && + !isSameFloatingPoint(getDatatype()) && + !isSameComplexFloatingPoint(getDatatype()) && + !isSameChar(getDatatype())) + { + std::string const data_type_str = datatypeToString(getDatatype()); + std::string const requ_type_str = + datatypeToString(determineDatatype()); + std::string err_msg = + "Type conversion during chunk loading not yet implemented! "; + err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; + throw std::runtime_error(err_msg); + } + + auto dim = getDimensionality(); + auto [offset, extent, memorySelection] = std::move(cfg); + + if (extent.size() != dim || offset.size() != dim) + { + std::ostringstream oss; + oss << "Dimensionality of chunk (" + << "offset=" << offset.size() << "D, " + << "extent=" << extent.size() << "D) " + << "and record component (" << int(dim) << "D) " + << "do not match."; + throw std::runtime_error(oss.str()); + } + Extent dse = getExtent(); + for (uint8_t i = 0; i < dim; ++i) + if (dse[i] < offset[i] + extent[i]) + throw std::runtime_error( + "Chunk does not reside inside dataset (Dimension on index " + + std::to_string(i) + ". DS: " + std::to_string(dse[i]) + + " - Chunk: " + std::to_string(offset[i] + extent[i]) + ")"); + + auto &rc = get(); + if (constant()) + { + uint64_t numPoints = 1u; + for (auto const &dimensionSize : extent) + numPoints *= dimensionSize; + + std::optional val = + switchNonVectorType>( + /* from = */ getDatatype(), rc.m_constantValue); + + if (val.has_value()) + { + auto raw_ptr = static_cast(data.get()); + std::fill(raw_ptr, raw_ptr + numPoints, *val); + } + else + { + std::string const data_type_str = datatypeToString(getDatatype()); + std::string const requ_type_str = + datatypeToString(determineDatatype()); + std::string err_msg = + "Type conversion during chunk loading not possible! "; + err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; + throw error::WrongAPIUsage(err_msg); + } + } + else + { + Parameter dRead; + dRead.offset = offset; + dRead.extent = extent; + dRead.dtype = getDatatype(); + dRead.data = std::static_pointer_cast(data); + rc.push_chunk(IOTask(this, dRead)); + } +} + template void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) { @@ -1024,7 +1204,9 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const template DynamicMemoryView RecordComponent::storeChunk( \ Offset offset, Extent extent); \ template void RecordComponent::storeChunkRaw( \ - OPENPMD_PTR(type const) ptr, Offset offset, Extent extent); + OPENPMD_PTR(type const) ptr, Offset offset, Extent extent); \ + template DynamicMemoryView RecordComponent::storeChunkSpan_impl( \ + internal::LoadStoreConfig cfg); #define OPENPMD_INSTANTIATE_CONST_AND_NONCONST(type) \ template void RecordComponent::storeChunk( \ @@ -1036,7 +1218,11 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const template std::shared_ptr RecordComponent::loadChunk( \ Offset o, Extent e); \ template void RecordComponent::storeChunk( \ - UniquePtrWithLambda data, Offset o, Extent e); + UniquePtrWithLambda data, Offset o, Extent e); \ + template void RecordComponent::loadChunk_impl( \ + std::shared_ptr data, internal::LoadStoreConfigWithBuffer cfg); \ + template std::shared_ptr RecordComponent::loadChunkAllocate_impl( \ + internal::LoadStoreConfig cfg); #define OPENPMD_INSTANTIATE_FULLMATRIX(type) \ template RecordComponent &RecordComponent::makeConstant(type); \ diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index d55ab3f2d7..025db3f355 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -45,7 +45,7 @@ template class DeferredComputation; #define INSTANTIATE_FUTURE(dtype) \ /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ template class DeferredComputation>; -OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_FUTURE) +OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_FUTURE) #undef INSTANTIATE_FUTURE // clang-format on } // namespace openPMD::auxiliary diff --git a/src/auxiliary/UniquePtr.cpp b/src/auxiliary/UniquePtr.cpp index 6625ca3a47..2818f96716 100644 --- a/src/auxiliary/UniquePtr.cpp +++ b/src/auxiliary/UniquePtr.cpp @@ -101,7 +101,7 @@ UniquePtrWithLambda::UniquePtrWithLambda( #define OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT(type) \ OPENPMD_INSTANTIATE(type) OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type)) -OPENPMD_FOREACH_DATASET_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT) +OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT) // Instantiate this directly, do not instantiate the // `std::unique_ptr`-based constructor. template class UniquePtrWithLambda; From 515dbbb20c6df3f3d75e64dc553436e7fbcad315 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 14:07:21 +0200 Subject: [PATCH 05/47] Adapt RecordComponent implementation based on new API --- include/openPMD/LoadStoreChunk.hpp | 7 +- include/openPMD/RecordComponent.hpp | 34 ---- include/openPMD/RecordComponent.tpp | 119 +++++--------- src/LoadStoreChunk.cpp | 10 +- src/RecordComponent.cpp | 247 ++++++---------------------- src/auxiliary/Future.cpp | 4 +- 6 files changed, 104 insertions(+), 317 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 8d6dee401f..ef9c2e5707 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -97,7 +97,8 @@ namespace core template struct shared_ptr_return_type_impl { - using type = ConfigureLoadStoreFromBuffer>; + using type = ConfigureLoadStoreFromBuffer< + std::shared_ptr>>; }; /* * ..., but if it is a const type, Load operations make no sense, so the @@ -106,8 +107,8 @@ namespace core template struct shared_ptr_return_type_impl { - using type = - ConfigureStoreChunkFromBuffer>; + using type = ConfigureStoreChunkFromBuffer< + std::shared_ptr const>>; }; template diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index 3c74d2a3b5..644e7acd2b 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -281,25 +281,6 @@ class RecordComponent : public BaseRecordComponent template void loadChunk(std::shared_ptr data, Offset offset, Extent extent); - /** Load a chunk of data into pre-allocated memory, array version. - * - * @param data Preallocated, contiguous buffer, large enough to load the - * the requested data into it. - * The shared pointer must own and manage the buffer. - * Optimizations might be implemented based on this - * assumption (e.g. skipping the operation if the backend - * is the unique owner). - * The array-based overload helps avoid having to manually - * specify the delete[] destructor (C++17 feature). - * @param offset Offset within the dataset. Set to {0u} for full selection. - * @param extent Extent within the dataset, counted from the offset. - * Set to {-1u} for full selection. - * If offset is non-zero and extent is {-1u} the leftover - * extent in the record component will be selected. - */ - template - void loadChunk(std::shared_ptr data, Offset offset, Extent extent); - /** Load a chunk of data into pre-allocated memory, raw pointer version. * * @param data Preallocated, contiguous buffer, large enough to load the @@ -339,18 +320,6 @@ class RecordComponent : public BaseRecordComponent template void storeChunk(std::shared_ptr data, Offset offset, Extent extent); - /** Store a chunk of data from a chunk of memory, array version. - * - * @param data Preallocated, contiguous buffer, large enough to read the - * the specified data from it. - * The array-based overload helps avoid having to manually - * specify the delete[] destructor (C++17 feature). - * @param offset Offset within the dataset. - * @param extent Extent within the dataset, counted from the offset. - */ - template - void storeChunk(std::shared_ptr data, Offset offset, Extent extent); - /** Store a chunk of data from a chunk of memory, unique pointer version. * * @param data Preallocated, contiguous buffer, large enough to read the @@ -512,9 +481,6 @@ class RecordComponent : public BaseRecordComponent */ RecordComponent &makeEmpty(Dataset d); - void storeChunk( - auxiliary::WriteBuffer buffer, Datatype datatype, Offset o, Extent e); - void storeChunk_impl( auxiliary::WriteBuffer buffer, Datatype datatype, diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp index bf1d6b7bd6..19cccc6789 100644 --- a/include/openPMD/RecordComponent.tpp +++ b/include/openPMD/RecordComponent.tpp @@ -23,6 +23,7 @@ #include "openPMD/Datatype.hpp" #include "openPMD/Error.hpp" +#include "openPMD/LoadStoreChunk.hpp" #include "openPMD/RecordComponent.hpp" #include "openPMD/Span.hpp" #include "openPMD/auxiliary/Memory.hpp" @@ -32,6 +33,7 @@ #include "openPMD/backend/Attributable.hpp" #include +#include #include namespace openPMD @@ -41,8 +43,11 @@ template inline void RecordComponent::storeChunk(std::unique_ptr data, Offset o, Extent e) { - storeChunk( - UniquePtrWithLambda(std::move(data)), std::move(o), std::move(e)); + prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .withUniquePtr(std::move(data)) + .store(EnqueuePolicy::Defer); } template @@ -50,39 +55,38 @@ inline typename std::enable_if_t< auxiliary::IsContiguousContainer_v> RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e) { - uint8_t dim = getDimensionality(); + auto storeChunkConfig = prepareLoadStore(); - // default arguments - // offset = {0u}: expand to right dim {0u, 0u, ...} - Offset offset = o; - if (o.size() == 1u && o.at(0) == 0u) + auto joined_dim = joinedDimension(); + if (!joined_dim.has_value() && (o.size() != 1 || o.at(0) != 0u)) { - if (joinedDimension().has_value()) - { - offset.clear(); - } - else if (dim > 1u) - { - offset = Offset(dim, 0u); - } + storeChunkConfig.offset(std::move(o)); + } + if (e.size() != 1 || e.at(0) != -1u) + { + storeChunkConfig.extent(std::move(e)); } - // extent = {-1u}: take full size - Extent extent(dim, 1u); - // avoid outsmarting the user: - // - stdlib data container implement 1D -> 1D chunk to write - if (e.size() == 1u && e.at(0) == -1u && dim == 1u) - extent.at(0) = data.size(); - else - extent = e; - - storeChunk(auxiliary::shareRaw(data.data()), offset, extent); + std::move(storeChunkConfig) + .withContiguousContainer(data) + .store(EnqueuePolicy::Defer); } template inline DynamicMemoryView RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer) { + return prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .enqueueStore(std::forward(createBuffer)); +} + +template +inline DynamicMemoryView RecordComponent::storeChunkSpanCreateBuffer_impl( + internal::LoadStoreConfig cfg, F &&createBuffer) +{ + auto [o, e] = std::move(cfg); verifyChunk(o, e); size_t size = 1; @@ -158,62 +162,6 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer) return DynamicMemoryView{std::move(getBufferView), size, *this}; } -template -inline DynamicMemoryView RecordComponent::storeChunkSpanCreateBuffer_impl( - internal::LoadStoreConfig cfg, F &&createBuffer) -{ - auto [o, e] = std::move(cfg); - verifyChunk(o, e); - - /* - * The openPMD backend might not yet know about this dataset. - * Flush the openPMD hierarchy to the backend without flushing any actual - * data yet. - */ - seriesFlush_impl( - {FlushLevel::SkeletonOnly}); - - size_t size = 1; - for (auto ext : e) - { - size *= ext; - } - /* - * Flushing the skeleton does not create datasets, - * so we might need to do it now. - */ - if (!written()) - { - auto &rc = get(); - if (!rc.m_dataset.has_value()) - { - throw error::WrongAPIUsage( - "[RecordComponent] Must specify dataset type and extent before " - "using storeChunk() (see RecordComponent::resetDataset())."); - } - Parameter dCreate(rc.m_dataset.value()); - dCreate.name = rc->m_writable.ownKeyWithinParent; - IOHandler()->enqueue(IOTask(this, dCreate)); - } - Parameter getBufferView; - getBufferView.offset = o; - getBufferView.extent = e; - getBufferView.dtype = getDatatype(); - IOHandler()->enqueue(IOTask(this, getBufferView)); - IOHandler()->flush(internal::defaultFlushParams); - auto &out = *getBufferView.out; - if (!out.backendManagedBuffer) - { - // note that data might have either - // type shared_ptr or shared_ptr - auto data = std::forward(createBuffer)(size); - out.ptr = static_cast(data.get()); - storeChunk(std::move(data), std::move(o), std::move(e)); - } - setDirtyRecursive(true); - return DynamicMemoryView{std::move(getBufferView), size, *this}; -} - namespace detail { template @@ -245,4 +193,13 @@ inline auto RecordComponent::visit(Args &&...args) return switchDatasetType>( getDatatype(), *this, std::forward(args)...); } + +// definitions for LoadStoreChunk.hpp +template +auto core::ConfigureLoadStore::enqueueStore(F &&createBuffer) + -> DynamicMemoryView +{ + return m_rc.storeChunkSpanCreateBuffer_impl( + storeChunkConfig(), std::forward(createBuffer)); +} } // namespace openPMD diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 526c01a3d9..6c65ac59d9 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -306,18 +306,22 @@ template class compose::ConfigureLoadStore; /* clang-format would destroy the NOLINT comments */ // clang-format off #define INSTANTIATE_METHOD_TEMPLATES(dtype) \ - template auto core::ConfigureLoadStore::enqueueStore() \ - -> DynamicMemoryView; \ template auto core::ConfigureLoadStore::enqueueLoad() \ /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ -> auxiliary::DeferredComputation>; \ template auto core::ConfigureLoadStore::load(EnqueuePolicy) \ ->std::shared_ptr; // clang-format on +#define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ + INSTANTIATE_METHOD_TEMPLATES(type) \ + INSTANTIATE_METHOD_TEMPLATES(type[]) template auto \ + core::ConfigureLoadStore::enqueueStore() -> DynamicMemoryView; -OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_METHOD_TEMPLATES) +OPENPMD_FOREACH_NONVECTOR_DATATYPE( + INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) #undef INSTANTIATE_METHOD_TEMPLATES +#undef INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT /* clang-format would destroy the NOLINT comments */ // clang-format off diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index 2fea07fa67..ec32bdf224 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -21,9 +21,9 @@ #include "openPMD/RecordComponent.hpp" #include "openPMD/Dataset.hpp" #include "openPMD/DatatypeHelpers.hpp" -#include "openPMD/DatatypeMacros.hpp" #include "openPMD/Error.hpp" #include "openPMD/IO/Format.hpp" +#include "openPMD/LoadStoreChunk.hpp" #include "openPMD/Series.hpp" #include "openPMD/auxiliary/Environment.hpp" #include "openPMD/auxiliary/Memory.hpp" @@ -35,6 +35,9 @@ // comment so clang-format does not move this #include "openPMD/DatatypeMacros.hpp" +// comment +#include "openPMD/DatatypeMacros.hpp" + #include #include #include @@ -700,21 +703,6 @@ void RecordComponent::readBase(bool require_unit_si) } } -void RecordComponent::storeChunk( - auxiliary::WriteBuffer buffer, Datatype dtype, Offset o, Extent e) -{ - verifyChunk(dtype, o, e); - - Parameter dWrite; - dWrite.offset = std::move(o); - dWrite.extent = std::move(e); - dWrite.dtype = dtype; - /* std::static_pointer_cast correctly reference-counts the pointer */ - dWrite.data = std::move(buffer); - auto &rc = get(); - rc.push_chunk(IOTask(this, std::move(dWrite))); -} - void RecordComponent::storeChunk_impl( auxiliary::WriteBuffer buffer, Datatype dtype, @@ -850,40 +838,22 @@ template std::shared_ptr RecordComponent::loadChunk(Offset o, Extent e) { uint8_t dim = getDimensionality(); + auto operation = prepareLoadStore(); // default arguments // offset = {0u}: expand to right dim {0u, 0u, ...} - Offset offset = o; - if (o.size() == 1u && o.at(0) == 0u && dim > 1u) - offset = Offset(dim, 0u); + if (o.size() != 1u || o.at(0) != 0u || dim <= 1u) + { + operation.offset(std::move(o)); + } // extent = {-1u}: take full size - Extent extent(dim, 1u); - if (e.size() == 1u && e.at(0) == -1u) + if (e.size() != 1u || e.at(0) != -1u) { - extent = getExtent(); - for (uint8_t i = 0u; i < dim; ++i) - extent[i] -= offset[i]; + operation.extent(std::move(e)); } - else - extent = e; - uint64_t numPoints = 1u; - for (auto const &dimensionSize : extent) - numPoints *= dimensionSize; - -#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) || \ - (defined(__apple_build_version__) && __clang_major__ < 14) - auto newData = - std::shared_ptr(new T[numPoints], [](T *p) { delete[] p; }); - loadChunk(newData, offset, extent); - return newData; -#else - auto newData = std::shared_ptr[]>( - new std::remove_extent_t[numPoints]); - loadChunk(newData, offset, extent); - return std::static_pointer_cast(std::move(newData)); -#endif + return operation.load(EnqueuePolicy::Defer); } namespace detail @@ -927,12 +897,10 @@ void RecordComponent::loadChunk_impl( * JSON/TOML backends as they might implicitly turn a LONG into an INT in a * constant component. The frontend needs to catch such edge cases. * Ref. `if (constant())` branch. + * + * Attention: Do NOT use operator==(), doesnt work properly on Windows! */ - if (dtype != getDatatype() && !constant()) - if (!isSameInteger(getDatatype()) && - !isSameFloatingPoint(getDatatype()) && - !isSameComplexFloatingPoint(getDatatype()) && - !isSameChar(getDatatype())) + if (!isSame(dtype, getDatatype()) && !constant()) { std::string const data_type_str = datatypeToString(getDatatype()); std::string const requ_type_str = @@ -1005,181 +973,74 @@ void RecordComponent::loadChunk_impl( template void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) { - Datatype dtype = determineDatatype(data); - /* - * For constant components, we implement type conversion, so there is - * a separate check further below. - * This is especially useful for the short-attribute representation in the - * JSON/TOML backends as they might implicitly turn a LONG into an INT in a - * constant component. The frontend needs to catch such edge cases. - * Ref. `if (constant())` branch. - * - * Attention: Do NOT use operator==(), doesnt work properly on Windows! - */ - if (!isSame(dtype, getDatatype()) && !constant()) - { - std::string const data_type_str = datatypeToString(getDatatype()); - std::string const requ_type_str = - datatypeToString(determineDatatype()); - std::string err_msg = - "Type conversion during chunk loading not yet implemented! "; - err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; - throw std::runtime_error(err_msg); - } - + // static_assert(!std::is_same_v, "EVIL"); uint8_t dim = getDimensionality(); + auto operation = prepareLoadStore(); // default arguments // offset = {0u}: expand to right dim {0u, 0u, ...} - Offset offset = o; - if (o.size() == 1u && o.at(0) == 0u && dim > 1u) - offset = Offset(dim, 0u); - - // extent = {-1u}: take full size - Extent extent(dim, 1u); - if (e.size() == 1u && e.at(0) == -1u) + if (o.size() != 1u || o.at(0) != 0u || dim <= 1u) { - extent = getExtent(); - for (uint8_t i = 0u; i < dim; ++i) - extent[i] -= offset[i]; + operation.offset(std::move(o)); } - else - extent = e; - - if (extent.size() != dim || offset.size() != dim) - { - std::ostringstream oss; - oss << "Dimensionality of chunk (" - << "offset=" << offset.size() << "D, " - << "extent=" << extent.size() << "D) " - << "and record component (" << int(dim) << "D) " - << "do not match."; - throw std::runtime_error(oss.str()); - } - Extent dse = getExtent(); - for (uint8_t i = 0; i < dim; ++i) - if (dse[i] < offset[i] + extent[i]) - throw std::runtime_error( - "Chunk does not reside inside dataset (Dimension on index " + - std::to_string(i) + ". DS: " + std::to_string(dse[i]) + - " - Chunk: " + std::to_string(offset[i] + extent[i]) + ")"); - if (!data) - throw std::runtime_error( - "Unallocated pointer passed during chunk loading."); - - auto &rc = get(); - if (constant()) - { - uint64_t numPoints = 1u; - for (auto const &dimensionSize : extent) - numPoints *= dimensionSize; - - std::optional val = - switchNonVectorType>( - /* dt = */ getDatatype(), rc.m_constantValue); - if (val.has_value()) - { - T *raw_ptr = data.get(); - std::fill(raw_ptr, raw_ptr + numPoints, *val); - } - else - { - std::string const data_type_str = datatypeToString(getDatatype()); - std::string const requ_type_str = - datatypeToString(determineDatatype()); - std::string err_msg = - "Type conversion during chunk loading not possible! "; - err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; - throw error::WrongAPIUsage(err_msg); - } - } - else + // extent = {-1u}: take full size + if (e.size() != 1u || e.at(0) != -1u) { - Parameter dRead; - dRead.offset = offset; - dRead.extent = extent; - dRead.dtype = getDatatype(); - dRead.data = std::static_pointer_cast(data); - rc.push_chunk(IOTask(this, dRead)); + operation.extent(std::move(e)); } -} -template -void RecordComponent::loadChunk( - std::shared_ptr ptr, Offset offset, Extent extent) -{ - loadChunk( - std::static_pointer_cast(std::move(ptr)), - std::move(offset), - std::move(extent)); + operation.withSharedPtr(std::move(data)).load(EnqueuePolicy::Defer); } template void RecordComponent::loadChunkRaw(T *ptr, Offset offset, Extent extent) { - loadChunk(auxiliary::shareRaw(ptr), std::move(offset), std::move(extent)); + prepareLoadStore() + .offset(std::move(offset)) + .extent(std::move(extent)) + .withRawPtr(ptr) + .load(EnqueuePolicy::Defer); } template void RecordComponent::storeChunk(std::shared_ptr data, Offset o, Extent e) { - if (!data) - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - Datatype dtype = determineDatatype(data); - - /* std::static_pointer_cast correctly reference-counts the pointer */ - storeChunk( - auxiliary::WriteBuffer(std::static_pointer_cast(data)), - dtype, - std::move(o), - std::move(e)); + prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .withSharedPtr(std::move(data)) + .store(EnqueuePolicy::Defer); } template void RecordComponent::storeChunk( UniquePtrWithLambda data, Offset o, Extent e) { - if (!data) - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - Datatype dtype = determineDatatype<>(data); - - storeChunk( - auxiliary::WriteBuffer{std::move(data).template static_cast_()}, - dtype, - std::move(o), - std::move(e)); -} - -template -void RecordComponent::storeChunk(std::shared_ptr data, Offset o, Extent e) -{ - storeChunk( - std::static_pointer_cast(std::move(data)), - std::move(o), - std::move(e)); + prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .withUniquePtr(std::move(data)) + .store(EnqueuePolicy::Defer); } template void RecordComponent::storeChunkRaw(T const *ptr, Offset offset, Extent extent) { - storeChunk(auxiliary::shareRaw(ptr), std::move(offset), std::move(extent)); + prepareLoadStore() + .offset(std::move(offset)) + .extent(std::move(extent)) + .withRawPtr(ptr) + .store(EnqueuePolicy::Defer); } template DynamicMemoryView RecordComponent::storeChunk(Offset offset, Extent extent) { - return storeChunk(std::move(offset), std::move(extent), [](size_t size) { -#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) || \ - (defined(__apple_build_version__) && __clang_major__ < 14) - return UniquePtrWithLambda{ - new T[size], [](auto *ptr) { delete[] ptr; }}; -#else - return std::unique_ptr{new T[size]}; -#endif - }); + return prepareLoadStore() + .offset(std::move(offset)) + .extent(std::move(extent)) + .enqueueStore(); } template @@ -1193,10 +1054,6 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const #define OPENPMD_ARRAY(type) type[] #define OPENPMD_INSTANTIATE_BASIC(type) \ - template void RecordComponent::loadChunk( \ - std::shared_ptr data, Offset o, Extent e); \ - template void RecordComponent::loadChunk( \ - std::shared_ptr data, Offset o, Extent e); \ template void RecordComponent::loadChunkRaw( \ OPENPMD_PTR(type) ptr, Offset offset, Extent extent); \ template void RecordComponent::verifyChunk( \ @@ -1208,13 +1065,11 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const template DynamicMemoryView RecordComponent::storeChunkSpan_impl( \ internal::LoadStoreConfig cfg); -#define OPENPMD_INSTANTIATE_CONST_AND_NONCONST(type) \ - template void RecordComponent::storeChunk( \ - std::shared_ptr data, Offset o, Extent e); \ - template void RecordComponent::storeChunk( \ - std::shared_ptr data, Offset o, Extent e); +#define OPENPMD_INSTANTIATE_CONST_AND_NONCONST(type) #define OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT(type) \ + template void RecordComponent::loadChunk( \ + std::shared_ptr data, Offset o, Extent e); \ template std::shared_ptr RecordComponent::loadChunk( \ Offset o, Extent e); \ template void RecordComponent::storeChunk( \ @@ -1225,6 +1080,8 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const internal::LoadStoreConfig cfg); #define OPENPMD_INSTANTIATE_FULLMATRIX(type) \ + template void RecordComponent::storeChunk( \ + std::shared_ptr data, Offset o, Extent e); \ template RecordComponent &RecordComponent::makeConstant(type); \ template RecordComponent &RecordComponent::makeEmpty( \ uint8_t dimensions); diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 025db3f355..25561e34c5 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -45,8 +45,10 @@ template class DeferredComputation; #define INSTANTIATE_FUTURE(dtype) \ /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ template class DeferredComputation>; -OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_FUTURE) +#define INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT(type) INSTANTIATE_FUTURE(type) INSTANTIATE_FUTURE(type[]) +OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT) #undef INSTANTIATE_FUTURE +#undef INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT // clang-format on } // namespace openPMD::auxiliary From 1f6dab0d4b6cf894e2ed8f1d844201b8878f8fd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 14:08:38 +0200 Subject: [PATCH 06/47] Testing --- test/ParallelIOTest.cpp | 69 +++++++++++++++++++++++++++++++++++++++-- test/SerialIOTest.cpp | 22 ++++++++----- 2 files changed, 82 insertions(+), 9 deletions(-) diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp index 9c28f52945..a9293e4b24 100644 --- a/test/ParallelIOTest.cpp +++ b/test/ParallelIOTest.cpp @@ -454,13 +454,42 @@ void available_chunks_test(std::string const &file_ending) } )END"; - std::vector data{2, 4, 6, 8}; + std::vector xdata{2, 4, 6, 8}; + std::vector 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 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.prepareLoadStore() + .withContiguousContainer(ydata_firstandlastrow) + .offset({0, 3ul * mpi_rank}) + .extent({1, 3}) + .enqueueStore(); + E_y.prepareLoadStore() + .offset({1, 3ul * mpi_rank}) + .extent({3, 3}) + .withContiguousContainer(ydata) + .memorySelection({{1, 1}, {5, 5}}) + .enqueueStore(); + // if condition checks if this PR is available in ADIOS2: + // https://github.com/ornladios/ADIOS2/pull/4169 + if constexpr (CanTheMemorySelectionBeReset) + { + E_y.prepareLoadStore() + .withContiguousContainer(ydata_firstandlastrow) + .offset({4, 3ul * mpi_rank}) + .extent({1, 3}) + .enqueueStore(); + } it0.close(); } @@ -492,6 +521,42 @@ 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.prepareLoadStore().extent({1, width}).enqueueLoad().get(); + auto middle_rows = E_y.prepareLoadStore() + .offset({1, 0}) + .extent({3, width}) + .enqueueLoad() + .get(); + auto last_row = + E_y.prepareLoadStore().offset({4, 0}).enqueueLoad().get(); + read.flush(); + + for (auto row : [&]() -> std::vector *> { + 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); + } } } diff --git a/test/SerialIOTest.cpp b/test/SerialIOTest.cpp index 49aab1db18..42cb5b2087 100644 --- a/test/SerialIOTest.cpp +++ b/test/SerialIOTest.cpp @@ -942,7 +942,11 @@ inline void constant_scalar(std::string const &file_ending) new unsigned int[6], [](unsigned int const *p) { delete[] p; }); unsigned int e{0}; std::generate(E.get(), E.get() + 6, [&e] { return e++; }); - E_y.storeChunk(std::move(E), {0, 0, 0}, {1, 2, 3}); + // check that const-type unique pointers work in the builder pattern + E_y.prepareLoadStore() + .extent({1, 2, 3}) + .withUniquePtr(std::move(E).static_cast_()) + .enqueueStore(); // store a number of predefined attributes in E Mesh &E_mesh = s.snapshots()[1].meshes["E"]; @@ -1753,13 +1757,17 @@ inline void write_test( auto opaqueTypeDataset = rc.visit(); auto variantTypeDataset = rc.loadChunkVariant(); + auto variantTypeDataset2 = rc.prepareLoadStore().enqueueLoadVariant().get(); rc.seriesFlush(); - std::visit( - [](auto &&shared_ptr) { - std::cout << "First value in loaded chunk: '" << shared_ptr.get()[0] - << '\'' << std::endl; - }, - variantTypeDataset); + for (auto ptr : {&variantTypeDataset, &variantTypeDataset2}) + { + std::visit( + [](auto &&shared_ptr) { + std::cout << "First value in loaded chunk: '" + << shared_ptr.get()[0] << '\'' << std::endl; + }, + *ptr); + } #ifndef _WIN32 if (test_rank_table) From 47716c55bec2ac1e7c84599b34576cff712de5e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 16:08:22 +0200 Subject: [PATCH 07/47] Enable support for const unique pointers? --- src/LoadStoreChunk.cpp | 8 +++++--- src/auxiliary/UniquePtr.cpp | 5 ++++- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 6c65ac59d9..d2bce73371 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -314,8 +314,9 @@ template class compose::ConfigureLoadStore; // clang-format on #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ - INSTANTIATE_METHOD_TEMPLATES(type[]) template auto \ - core::ConfigureLoadStore::enqueueStore() -> DynamicMemoryView; + INSTANTIATE_METHOD_TEMPLATES(type[]) \ + template auto core::ConfigureLoadStore::enqueueStore() \ + -> DynamicMemoryView; OPENPMD_FOREACH_NONVECTOR_DATATYPE( INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) @@ -353,7 +354,8 @@ OPENPMD_FOREACH_NONVECTOR_DATATYPE( #define INSTANTIATE_STORE_CHUNK_FROM_BUFFER(dtype) \ INSTANTIATE_FULL(std::shared_ptr) \ INSTANTIATE_HALF(std::shared_ptr) \ - INSTANTIATE_HALF(UniquePtrWithLambda) + INSTANTIATE_HALF(UniquePtrWithLambda) \ + INSTANTIATE_HALF(UniquePtrWithLambda) // /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) diff --git a/src/auxiliary/UniquePtr.cpp b/src/auxiliary/UniquePtr.cpp index 2818f96716..474441fdd3 100644 --- a/src/auxiliary/UniquePtr.cpp +++ b/src/auxiliary/UniquePtr.cpp @@ -99,7 +99,10 @@ UniquePtrWithLambda::UniquePtrWithLambda( std::unique_ptr); #define OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT(type) \ - OPENPMD_INSTANTIATE(type) OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type)) + OPENPMD_INSTANTIATE(type) \ + OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type)) \ + OPENPMD_INSTANTIATE(type const) \ + OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type const)) OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT) // Instantiate this directly, do not instantiate the From d9cc1549673602942e4aeaebc7585d1a0d6a9e6e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 7 Aug 2025 16:15:21 +0200 Subject: [PATCH 08/47] Use a better trick to cheat clang-tidy --- src/LoadStoreChunk.cpp | 50 +++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 27 deletions(-) diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index d2bce73371..710417b2b7 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -303,18 +303,19 @@ namespace compose template class compose::ConfigureLoadStore; -/* clang-format would destroy the NOLINT comments */ -// clang-format off +// need this for clang-tidy +#define OPENPMD_ARRAY(type) type[] +#define OPENPMD_APPLY_TEMPLATE(template_, type) template_ + #define INSTANTIATE_METHOD_TEMPLATES(dtype) \ template auto core::ConfigureLoadStore::enqueueLoad() \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - -> auxiliary::DeferredComputation>; \ + -> auxiliary::DeferredComputation; \ template auto core::ConfigureLoadStore::load(EnqueuePolicy) \ ->std::shared_ptr; -// clang-format on #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ - INSTANTIATE_METHOD_TEMPLATES(type[]) \ + INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type)) \ template auto core::ConfigureLoadStore::enqueueStore() \ -> DynamicMemoryView; @@ -324,39 +325,32 @@ OPENPMD_FOREACH_NONVECTOR_DATATYPE( #undef INSTANTIATE_METHOD_TEMPLATES #undef INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT -/* clang-format would destroy the NOLINT comments */ -// clang-format off #define INSTANTIATE_HALF(pointer_type) \ - template class ConfigureStoreChunkFromBuffer; \ - template class core::ConfigureStoreChunkFromBuffer; \ - template class compose::ConfigureLoadStore< \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - ConfigureStoreChunkFromBuffer>; \ + template class OPENPMD_APPLY_TEMPLATE( \ + ConfigureStoreChunkFromBuffer, pointer_type); \ + template class core::OPENPMD_APPLY_TEMPLATE( \ + ConfigureStoreChunkFromBuffer, pointer_type); \ + template class compose::ConfigureLoadStore; \ template class compose::ConfigureStoreChunkFromBuffer< \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - ConfigureStoreChunkFromBuffer>; -// clang-format on + OPENPMD_APPLY_TEMPLATE(ConfigureStoreChunkFromBuffer, pointer_type)>; -/* clang-format would destroy the NOLINT comments */ -// clang-format off #define INSTANTIATE_FULL(pointer_type) \ INSTANTIATE_HALF(pointer_type) \ - template class ConfigureLoadStoreFromBuffer; \ - template class core::ConfigureLoadStoreFromBuffer; \ - template class compose::ConfigureLoadStore< \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - ConfigureLoadStoreFromBuffer>; \ + template class OPENPMD_APPLY_TEMPLATE( \ + ConfigureLoadStoreFromBuffer, pointer_type); \ + template class core::OPENPMD_APPLY_TEMPLATE( \ + ConfigureLoadStoreFromBuffer, pointer_type); \ + template class compose::ConfigureLoadStore; \ template class compose::ConfigureStoreChunkFromBuffer< \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - ConfigureLoadStoreFromBuffer>; -// clang-format on + OPENPMD_APPLY_TEMPLATE(ConfigureLoadStoreFromBuffer, pointer_type)>; #define INSTANTIATE_STORE_CHUNK_FROM_BUFFER(dtype) \ INSTANTIATE_FULL(std::shared_ptr) \ INSTANTIATE_HALF(std::shared_ptr) \ INSTANTIATE_HALF(UniquePtrWithLambda) \ INSTANTIATE_HALF(UniquePtrWithLambda) -// /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) @@ -364,6 +358,8 @@ OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) #undef INSTANTIATE_METHOD_TEMPLATES #undef INSTANTIATE_FULL #undef INSTANTIATE_HALF +#undef OPENPMD_ARRAY +#undef OPENPMD_APPLY_TEMPLATE ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) : core::ConfigureLoadStore{rc} From beca7533469555dfb2eed7d790a30c23fb20be30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Fri, 8 Aug 2025 11:59:33 +0200 Subject: [PATCH 09/47] clang-tidy fixes --- src/RecordComponent.cpp | 2 +- src/auxiliary/Future.cpp | 16 +++++++++++----- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index ec32bdf224..40b68412e7 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -941,7 +941,7 @@ void RecordComponent::loadChunk_impl( std::optional val = switchNonVectorType>( - /* from = */ getDatatype(), rc.m_constantValue); + /* dt = */ getDatatype(), rc.m_constantValue); if (val.has_value()) { diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 25561e34c5..0abbf3bdf3 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -41,15 +41,21 @@ auto DeferredComputation::valid() const noexcept -> bool template class DeferredComputation; template class DeferredComputation; -// clang-format off + +// need this for clang-tidy +#define OPENPMD_ARRAY(type) type[] +#define OPENPMD_APPLY_TEMPLATE(template_, type) template_ + #define INSTANTIATE_FUTURE(dtype) \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - template class DeferredComputation>; -#define INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT(type) INSTANTIATE_FUTURE(type) INSTANTIATE_FUTURE(type[]) + template class DeferredComputation; +#define INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT(type) \ + INSTANTIATE_FUTURE(type) INSTANTIATE_FUTURE(OPENPMD_ARRAY(type)) OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT) #undef INSTANTIATE_FUTURE #undef INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT -// clang-format on +#undef OPENPMD_ARRAY +#undef OPENPMD_APPLY_TEMPLATE } // namespace openPMD::auxiliary #include "openPMD/UndefDatatypeMacros.hpp" From fca39020e97f35851816c716ae4f7f4711bf7f27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 8 Jan 2026 13:37:52 +0100 Subject: [PATCH 10/47] Fix linker error --- src/LoadStoreChunk.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 710417b2b7..ee8595bea3 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -319,7 +319,7 @@ template class compose::ConfigureLoadStore; template auto core::ConfigureLoadStore::enqueueStore() \ -> DynamicMemoryView; -OPENPMD_FOREACH_NONVECTOR_DATATYPE( +OPENPMD_FOREACH_DATASET_DATATYPE( INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) #undef INSTANTIATE_METHOD_TEMPLATES @@ -352,7 +352,7 @@ OPENPMD_FOREACH_NONVECTOR_DATATYPE( INSTANTIATE_HALF(UniquePtrWithLambda) \ INSTANTIATE_HALF(UniquePtrWithLambda) -OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) +OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) #undef INSTANTIATE_STORE_CHUNK_FROM_BUFFER #undef INSTANTIATE_METHOD_TEMPLATES From f09efaf60adae5807587b4542daad5739bd7813d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 8 Jan 2026 13:38:22 +0100 Subject: [PATCH 11/47] Reimplement unique_ptr-based span API --- src/RecordComponent.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index 40b68412e7..28b608876b 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -205,13 +205,14 @@ namespace template auto createSpanBufferFallback(size_t size) -> std::shared_ptr { - return std::shared_ptr{new T[size], [](auto *ptr) { delete[] ptr; }}; + return UniquePtrWithLambda{ + new T[size], [](auto *ptr) { delete[] ptr; }}; } #else template auto createSpanBufferFallback(size_t size) -> std::shared_ptr { - return std::shared_ptr{new T[size]}; + return std::unique_ptr{new T[size]}; } #endif } // namespace From b58ef9229eaaef9d7faf0e3de76374c3fa9ccab0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 8 Jan 2026 13:38:45 +0100 Subject: [PATCH 12/47] Fix parallel tests --- test/ParallelIOTest.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp index a9293e4b24..e61d5c2d14 100644 --- a/test/ParallelIOTest.cpp +++ b/test/ParallelIOTest.cpp @@ -494,7 +494,11 @@ void available_chunks_test(std::string const &file_ending) } { - Series read(name, Access::READ_ONLY, MPI_COMM_WORLD); + Series read( + name, + Access::READ_ONLY, + MPI_COMM_WORLD, + R"({"verify_homogeneous_extents": false})"); Iteration it0 = read.iterations[0]; auto E_x = it0.meshes["E"]["x"]; ChunkTable table = E_x.availableChunks(); From 1057d0ac8768d20c6bad59be0775aa5ce29fda26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 8 Jan 2026 17:30:13 +0100 Subject: [PATCH 13/47] Type signature fix --- src/RecordComponent.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index 28b608876b..b68714e1b8 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -203,14 +203,14 @@ namespace #if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) || \ (defined(__apple_build_version__) && __clang_major__ < 14) template - auto createSpanBufferFallback(size_t size) -> std::shared_ptr + auto createSpanBufferFallback(size_t size) -> UniquePtrWithLambda { return UniquePtrWithLambda{ new T[size], [](auto *ptr) { delete[] ptr; }}; } #else template - auto createSpanBufferFallback(size_t size) -> std::shared_ptr + auto createSpanBufferFallback(size_t size) -> std::unique_ptr { return std::unique_ptr{new T[size]}; } From 7b7a18d8aef8bde7dc2e609639395c63cffc7a63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Fri, 9 Jan 2026 15:08:12 +0100 Subject: [PATCH 14/47] Destructor for ~DeferredComputation --- include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp | 4 +- include/openPMD/IO/AbstractIOHandler.hpp | 7 +++- include/openPMD/IO/DummyIOHandler.hpp | 2 +- include/openPMD/IO/HDF5/HDF5IOHandler.hpp | 2 +- .../openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp | 2 +- include/openPMD/IO/JSON/JSONIOHandler.hpp | 2 +- include/openPMD/LoadStoreChunk.hpp | 6 +++ include/openPMD/auxiliary/Future.hpp | 1 + include/openPMD/backend/Attributable.hpp | 6 +++ src/IO/ADIOS/ADIOS2IOHandler.cpp | 2 +- src/IO/AbstractIOHandler.cpp | 16 +++++++ src/IO/DummyIOHandler.cpp | 2 +- src/IO/HDF5/HDF5IOHandler.cpp | 2 +- src/IO/HDF5/ParallelHDF5IOHandler.cpp | 2 +- src/IO/JSON/JSONIOHandler.cpp | 2 +- src/LoadStoreChunk.cpp | 42 +++++++++++++------ src/auxiliary/Future.cpp | 22 ++++++++++ 17 files changed, 97 insertions(+), 25 deletions(-) diff --git a/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp index c2185a0f96..656f249b6b 100644 --- a/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp +++ b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp @@ -957,7 +957,7 @@ class ADIOS2IOHandler : public AbstractIOHandler try { auto params = internal::defaultParsedFlushParams; - this->flush(params); + this->flush_impl(params); } catch (std::exception const &ex) { @@ -1005,6 +1005,6 @@ class ADIOS2IOHandler : public AbstractIOHandler return true; } - std::future flush(internal::ParsedFlushParams &) override; + std::future flush_impl(internal::ParsedFlushParams &) override; }; // ADIOS2IOHandler } // namespace openPMD diff --git a/include/openPMD/IO/AbstractIOHandler.hpp b/include/openPMD/IO/AbstractIOHandler.hpp index 9b7735b5ba..6429328c22 100644 --- a/include/openPMD/IO/AbstractIOHandler.hpp +++ b/include/openPMD/IO/AbstractIOHandler.hpp @@ -265,13 +265,15 @@ class AbstractIOHandler * backends that decide to implement this operation asynchronously. */ std::future flush(internal::FlushParams const &); + std::shared_ptr m_flushCounter = + std::make_shared(0); /** Process operations in queue according to FIFO. * * @return Future indicating the completion state of the operation for * backends that decide to implement this operation asynchronously. */ - virtual std::future flush(internal::ParsedFlushParams &) = 0; + std::future flush(internal::ParsedFlushParams &); /** The currently used backend */ virtual std::string backendName() const = 0; @@ -315,6 +317,9 @@ class AbstractIOHandler IterationEncoding m_encoding = IterationEncoding::groupBased; OpenpmdStandard m_standard = auxiliary::parseStandard(getStandardDefault()); bool m_verify_homogeneous_extents = true; + +protected: + virtual std::future flush_impl(internal::ParsedFlushParams &) = 0; }; // AbstractIOHandler } // namespace openPMD diff --git a/include/openPMD/IO/DummyIOHandler.hpp b/include/openPMD/IO/DummyIOHandler.hpp index 8abcf20990..100711c944 100644 --- a/include/openPMD/IO/DummyIOHandler.hpp +++ b/include/openPMD/IO/DummyIOHandler.hpp @@ -44,7 +44,7 @@ class DummyIOHandler : public AbstractIOHandler /** No-op consistent with the IOHandler interface to enable library use * without IO. */ - std::future flush(internal::ParsedFlushParams &) override; + std::future flush_impl(internal::ParsedFlushParams &) override; std::string backendName() const override; }; // DummyIOHandler } // namespace openPMD diff --git a/include/openPMD/IO/HDF5/HDF5IOHandler.hpp b/include/openPMD/IO/HDF5/HDF5IOHandler.hpp index 07b3978b87..5e2ddfd526 100644 --- a/include/openPMD/IO/HDF5/HDF5IOHandler.hpp +++ b/include/openPMD/IO/HDF5/HDF5IOHandler.hpp @@ -46,7 +46,7 @@ class HDF5IOHandler : public AbstractIOHandler return "HDF5"; } - std::future flush(internal::ParsedFlushParams &) override; + std::future flush_impl(internal::ParsedFlushParams &) override; private: std::unique_ptr m_impl; diff --git a/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp b/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp index abeb196b11..7b0c43129d 100644 --- a/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp +++ b/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp @@ -56,7 +56,7 @@ class ParallelHDF5IOHandler : public AbstractIOHandler return "MPI_HDF5"; } - std::future flush(internal::ParsedFlushParams &) override; + std::future flush_impl(internal::ParsedFlushParams &) override; private: std::unique_ptr m_impl; diff --git a/include/openPMD/IO/JSON/JSONIOHandler.hpp b/include/openPMD/IO/JSON/JSONIOHandler.hpp index 07e797d4b3..db8b687ed9 100644 --- a/include/openPMD/IO/JSON/JSONIOHandler.hpp +++ b/include/openPMD/IO/JSON/JSONIOHandler.hpp @@ -59,7 +59,7 @@ class JSONIOHandler : public AbstractIOHandler return "JSON"; } - std::future flush(internal::ParsedFlushParams &) override; + std::future flush_impl(internal::ParsedFlushParams &) override; private: JSONIOHandlerImpl m_impl; diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index ef9c2e5707..e579c54ae2 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -22,6 +22,7 @@ template class ConfigureLoadStoreFromBuffer; template class DynamicMemoryView; +class Attributable; namespace internal { @@ -87,6 +88,8 @@ namespace core [[nodiscard]] auto dim() const -> uint8_t; auto storeChunkConfig() -> internal::LoadStoreConfig; + auto deferFlush(Attributable &); + public: auto getOffset() -> Offset const &; auto getExtent() -> Extent const &; @@ -228,9 +231,12 @@ namespace compose template class ConfigureLoadStore { + ConfigureLoadStore() = default; + public: auto offset(Offset) -> ChildClass &; auto extent(Extent) -> ChildClass &; + friend ChildClass; }; /** Configuration for a Store operation with a buffer type. diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index d40f7372fb..8a4b2a516c 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -15,6 +15,7 @@ class DeferredComputation public: DeferredComputation(task_type); + ~DeferredComputation(); auto get() -> T; diff --git a/include/openPMD/backend/Attributable.hpp b/include/openPMD/backend/Attributable.hpp index 705080be84..b133f28e07 100644 --- a/include/openPMD/backend/Attributable.hpp +++ b/include/openPMD/backend/Attributable.hpp @@ -213,6 +213,11 @@ namespace debug void printDirty(Series const &); } +namespace core +{ + class ConfigureLoadStore; +} + /** @brief Layer to manage storage of attributes associated with file objects. * * Mandatory and user-defined Attributes and their data for every object in the @@ -244,6 +249,7 @@ class Attributable friend class internal::AttributableData; friend class Snapshots; friend struct internal::HomogenizeExtents; + friend class core::ConfigureLoadStore; protected: // tag for internal constructor diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp index 3abb6d8b54..6571957b40 100644 --- a/src/IO/ADIOS/ADIOS2IOHandler.cpp +++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp @@ -2628,7 +2628,7 @@ ADIOS2IOHandler::ADIOS2IOHandler( {} std::future -ADIOS2IOHandler::flush(internal::ParsedFlushParams &flushParams) +ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &flushParams) { return m_impl.flush(flushParams); } diff --git a/src/IO/AbstractIOHandler.cpp b/src/IO/AbstractIOHandler.cpp index 5f2bdeb2f5..0614f26292 100644 --- a/src/IO/AbstractIOHandler.cpp +++ b/src/IO/AbstractIOHandler.cpp @@ -122,6 +122,22 @@ std::future AbstractIOHandler::flush(internal::FlushParams const ¶ms) return future; } +std::future AbstractIOHandler::flush(internal::ParsedFlushParams ¶ms) +{ + // The flush counter indicates the number of times that m_work has been + // emptied. Only increment it if m_work was full before operation and is + // empty after operation. + // Enqueuers can use this counter to check if the enqueued operation has + // been flushed already. + bool increase_flush_counter = !m_work.empty(); + auto res = this->flush_impl(params); + if (increase_flush_counter && m_work.empty()) + { + ++*m_flushCounter; + } + return res; +} + bool AbstractIOHandler::fullSupportForVariableBasedEncoding() const { return false; diff --git a/src/IO/DummyIOHandler.cpp b/src/IO/DummyIOHandler.cpp index f3b4e155d2..52c83bb624 100644 --- a/src/IO/DummyIOHandler.cpp +++ b/src/IO/DummyIOHandler.cpp @@ -39,7 +39,7 @@ DummyIOHandler::DummyIOHandler(std::string path, Access at) void DummyIOHandler::enqueue(IOTask const &) {} -std::future DummyIOHandler::flush(internal::ParsedFlushParams &) +std::future DummyIOHandler::flush_impl(internal::ParsedFlushParams &) { return std::future(); } diff --git a/src/IO/HDF5/HDF5IOHandler.cpp b/src/IO/HDF5/HDF5IOHandler.cpp index f8c1299a10..68e27d80b0 100644 --- a/src/IO/HDF5/HDF5IOHandler.cpp +++ b/src/IO/HDF5/HDF5IOHandler.cpp @@ -3592,7 +3592,7 @@ HDF5IOHandler::HDF5IOHandler( HDF5IOHandler::~HDF5IOHandler() = default; -std::future HDF5IOHandler::flush(internal::ParsedFlushParams ¶ms) +std::future HDF5IOHandler::flush_impl(internal::ParsedFlushParams ¶ms) { return m_impl->flush(params); } diff --git a/src/IO/HDF5/ParallelHDF5IOHandler.cpp b/src/IO/HDF5/ParallelHDF5IOHandler.cpp index 7de4960feb..dad31620b6 100644 --- a/src/IO/HDF5/ParallelHDF5IOHandler.cpp +++ b/src/IO/HDF5/ParallelHDF5IOHandler.cpp @@ -76,7 +76,7 @@ ParallelHDF5IOHandler::ParallelHDF5IOHandler( ParallelHDF5IOHandler::~ParallelHDF5IOHandler() = default; std::future -ParallelHDF5IOHandler::flush(internal::ParsedFlushParams ¶ms) +ParallelHDF5IOHandler::flush_impl(internal::ParsedFlushParams ¶ms) { if (auto hdf5_config_it = params.backendConfig.json().find("hdf5"); hdf5_config_it != params.backendConfig.json().end()) diff --git a/src/IO/JSON/JSONIOHandler.cpp b/src/IO/JSON/JSONIOHandler.cpp index c531aabb00..0e167b801b 100644 --- a/src/IO/JSON/JSONIOHandler.cpp +++ b/src/IO/JSON/JSONIOHandler.cpp @@ -53,7 +53,7 @@ JSONIOHandler::JSONIOHandler( {} #endif -std::future JSONIOHandler::flush(internal::ParsedFlushParams &) +std::future JSONIOHandler::flush_impl(internal::ParsedFlushParams &) { return m_impl.flush(); } diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index ee8595bea3..1ee646948b 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -11,6 +11,7 @@ // comment to keep clang-format from reordering #include "openPMD/DatatypeMacros.hpp" +#include "openPMD/backend/Attributable.hpp" #include #include @@ -70,6 +71,21 @@ namespace core return internal::LoadStoreConfig{getOffset(), getExtent()}; } + auto ConfigureLoadStore::deferFlush(Attributable &attr) + { + auto index = attr.IOHandler()->m_flushCounter; + return [attr, + old_index = *index, + current_index = std::weak_ptr(index)]() mutable { + auto lock_current_index = current_index.lock(); + if (!lock_current_index || *lock_current_index >= old_index) + { + return; + } + attr.seriesFlush(); + }; + } + auto ConfigureLoadStore::getOffset() -> Offset const & { if (!m_offset.has_value()) @@ -118,8 +134,8 @@ namespace core { auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); return auxiliary::DeferredComputation>( - [res_lambda = std::move(res), rc = m_rc]() mutable { - rc.seriesFlush(); + [res_lambda = std::move(res), dflush = deferFlush(m_rc)]() mutable { + dflush(); return res_lambda; }); } @@ -141,20 +157,19 @@ namespace core struct VisitorEnqueueLoadVariant { - template - static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) + template + static auto + call(RecordComponent &rc, internal::LoadStoreConfig cfg, F &&dflush) -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types> { auto res = rc.loadChunkAllocate_impl(std::move(cfg)); return auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types>( - - [res_lambda = std::move(res), rc_lambda = rc]() mutable + [res_lambda = std::move(res), + dflush_lambda = std::forward(dflush)]() mutable -> auxiliary::detail::shared_ptr_dataset_types { - std::cout << "Flushing Series from Future" << std::endl; - rc_lambda.seriesFlush(); - std::cout << "Flushed Series from Future" << std::endl; + dflush_lambda(); return res_lambda; }); } @@ -164,7 +179,8 @@ namespace core -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types> { - return m_rc.visit(this->storeChunkConfig()); + return m_rc.visit( + this->storeChunkConfig(), deferFlush(m_rc)); } struct VisitorLoadVariant @@ -215,7 +231,7 @@ namespace core determineDatatype>(), storeChunkConfig()); return auxiliary::DeferredComputation( - [rc_lambda = m_rc]() mutable -> void { rc_lambda.seriesFlush(); }); + [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); } template @@ -251,8 +267,8 @@ namespace core this->m_rc.loadChunk_impl( std::move(this->m_buffer), this->storeChunkConfig()); return auxiliary::DeferredComputation( - [rc_lambda = this->m_rc]() mutable -> void { - rc_lambda.seriesFlush(); + [dflush = this->deferFlush(this->m_rc)]() mutable -> void { + dflush(); }); } diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 0abbf3bdf3..6e91fb7119 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -27,6 +27,28 @@ DeferredComputation::DeferredComputation(task_type task) , m_valid(true) {} +template +DeferredComputation::~DeferredComputation() +{ + if (m_valid) + { + try + { + get(); + } + catch (std::exception const &e) + { + std::cerr << "[DeferredComputation] Error in destructor: '" + << e.what() << "'." << std::endl; + } + catch (...) + { + std::cerr << "[DeferredComputation] Unknown error in destructor." + << std::endl; + } + } +} + template auto DeferredComputation::get() -> T { From 95a31d6b6d2e1c23347e1ae45240a8e41fcd6f3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 3 Feb 2026 16:21:10 +0100 Subject: [PATCH 15/47] CI fixes --- src/IO/ADIOS/ADIOS2IOHandler.cpp | 2 +- src/IO/HDF5/HDF5IOHandler.cpp | 2 +- src/IO/HDF5/ParallelHDF5IOHandler.cpp | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp index 6571957b40..d3b19fde0f 100644 --- a/src/IO/ADIOS/ADIOS2IOHandler.cpp +++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp @@ -2669,7 +2669,7 @@ ADIOS2IOHandler::ADIOS2IOHandler( std::move(initialize_from), std::move(path), at, std::move(config)) {} -std::future ADIOS2IOHandler::flush(internal::ParsedFlushParams &) +std::future ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &) { return std::future(); } diff --git a/src/IO/HDF5/HDF5IOHandler.cpp b/src/IO/HDF5/HDF5IOHandler.cpp index 68e27d80b0..a6a97fa6ff 100644 --- a/src/IO/HDF5/HDF5IOHandler.cpp +++ b/src/IO/HDF5/HDF5IOHandler.cpp @@ -3611,7 +3611,7 @@ HDF5IOHandler::HDF5IOHandler( HDF5IOHandler::~HDF5IOHandler() = default; -std::future HDF5IOHandler::flush(internal::ParsedFlushParams &) +std::future HDF5IOHandler::flush_impl(internal::ParsedFlushParams &) { return std::future(); } diff --git a/src/IO/HDF5/ParallelHDF5IOHandler.cpp b/src/IO/HDF5/ParallelHDF5IOHandler.cpp index dad31620b6..0cf8b396a3 100644 --- a/src/IO/HDF5/ParallelHDF5IOHandler.cpp +++ b/src/IO/HDF5/ParallelHDF5IOHandler.cpp @@ -462,7 +462,8 @@ ParallelHDF5IOHandler::ParallelHDF5IOHandler( ParallelHDF5IOHandler::~ParallelHDF5IOHandler() = default; -std::future ParallelHDF5IOHandler::flush(internal::ParsedFlushParams &) +std::future +ParallelHDF5IOHandler::flush_impl(internal::ParsedFlushParams &) { return std::future(); } From c76cd468f4a1d460ba9dae29972931494fffbc86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 9 Feb 2026 16:30:44 +0100 Subject: [PATCH 16/47] wip: runtime-erase pointer type --- include/openPMD/LoadStoreChunk.hpp | 61 +++++++------ include/openPMD/LoadStoreChunk.tpp | 36 ++++++-- include/openPMD/RecordComponent.hpp | 8 +- include/openPMD/auxiliary/Memory.hpp | 13 ++- include/openPMD/auxiliary/Memory_internal.hpp | 6 +- src/IO/ADIOS/ADIOS2File.cpp | 4 +- src/LoadStoreChunk.cpp | 90 ++++++------------- src/auxiliary/Memory.cpp | 41 ++++++++- 8 files changed, 146 insertions(+), 113 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index e579c54ae2..dd98d9fb51 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -2,6 +2,7 @@ #include "openPMD/Dataset.hpp" #include "openPMD/auxiliary/Future.hpp" +#include "openPMD/auxiliary/Memory.hpp" #include "openPMD/auxiliary/ShareRawInternal.hpp" #include "openPMD/auxiliary/UniquePtr.hpp" @@ -16,9 +17,7 @@ namespace openPMD { class RecordComponent; -template class ConfigureStoreChunkFromBuffer; -template class ConfigureLoadStoreFromBuffer; template class DynamicMemoryView; @@ -100,8 +99,9 @@ namespace core template struct shared_ptr_return_type_impl { - using type = ConfigureLoadStoreFromBuffer< - std::shared_ptr>>; + using return_type = ConfigureLoadStoreFromBuffer; + using normalize_pointer_type = + std::shared_ptr>; }; /* * ..., but if it is a const type, Load operations make no sense, so the @@ -110,21 +110,27 @@ namespace core template struct shared_ptr_return_type_impl { - using type = ConfigureStoreChunkFromBuffer< - std::shared_ptr const>>; + using return_type = ConfigureStoreChunkFromBuffer; + using normalize_pointer_type = + std::shared_ptr const>; }; template - using shared_ptr_return_type = - typename shared_ptr_return_type_impl>::type; + using shared_ptr_return_type = typename shared_ptr_return_type_impl< + std::remove_extent_t>::return_type; + template + using shared_ptr_normalized_type = typename shared_ptr_return_type_impl< + std::remove_extent_t>::normalized_pointer_type; /* * As loading into unique pointer types makes no sense, the case is * simpler for unique pointers. Just remove the array extents here. */ template - using unique_ptr_return_type = ConfigureStoreChunkFromBuffer< - UniquePtrWithLambda>>; + using unique_ptr_return_type = ConfigureStoreChunkFromBuffer; + template + using unique_ptr_normalized_type = + UniquePtrWithLambda>; // @todo rvalue references..? template @@ -166,14 +172,15 @@ namespace core -> auxiliary::detail::shared_ptr_dataset_types; }; - template class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore { public: - Ptr_Type m_buffer; + auxiliary::WriteBuffer m_buffer; + Datatype m_datatype; std::optional m_mem_select; - ConfigureStoreChunkFromBuffer(Ptr_Type buffer, ConfigureLoadStore &&); + ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer buffer, Datatype, ConfigureLoadStore &&); auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; @@ -205,13 +212,10 @@ namespace core } }; - template - class ConfigureLoadStoreFromBuffer - : public ConfigureStoreChunkFromBuffer + class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer { public: - using ConfigureStoreChunkFromBuffer< - Ptr_Type>::ConfigureStoreChunkFromBuffer; + using ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; auto enqueueLoad() -> auxiliary::DeferredComputation; @@ -272,31 +276,26 @@ class ConfigureLoadStore ConfigureLoadStore(core::ConfigureLoadStore &&); }; -template class ConfigureStoreChunkFromBuffer - : public core::ConfigureStoreChunkFromBuffer - , public compose::ConfigureLoadStore< - ConfigureStoreChunkFromBuffer> + : public core::ConfigureStoreChunkFromBuffer + , public compose::ConfigureLoadStore , public compose::ConfigureStoreChunkFromBuffer< - ConfigureStoreChunkFromBuffer> + ConfigureStoreChunkFromBuffer> { friend class core::ConfigureLoadStore; - using core::ConfigureStoreChunkFromBuffer< - Ptr_Type>::ConfigureStoreChunkFromBuffer; + using core::ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; }; -template class ConfigureLoadStoreFromBuffer - : public core::ConfigureLoadStoreFromBuffer - , public compose::ConfigureLoadStore> + : public core::ConfigureLoadStoreFromBuffer + , public compose::ConfigureLoadStore , public compose::ConfigureStoreChunkFromBuffer< - ConfigureLoadStoreFromBuffer> + ConfigureLoadStoreFromBuffer> { friend class ConfigureLoadStoreCore; - using core::ConfigureLoadStoreFromBuffer< - Ptr_Type>::ConfigureLoadStoreFromBuffer; + using core::ConfigureLoadStoreFromBuffer::ConfigureLoadStoreFromBuffer; }; } // namespace openPMD diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp index c3c104cebd..4d0f1e4aa8 100644 --- a/include/openPMD/LoadStoreChunk.tpp +++ b/include/openPMD/LoadStoreChunk.tpp @@ -14,7 +14,11 @@ auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) "Unallocated pointer passed during chunk store."); } return shared_ptr_return_type( - std::static_pointer_cast>(std::move(data)), + auxiliary::WriteBuffer( + std::static_pointer_cast< + std::conditional_t, void const, void>>( + std::move(data))), + determineDatatype>(), {std::move(*this)}); } template @@ -27,9 +31,26 @@ auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) throw std::runtime_error( "Unallocated pointer passed during chunk store."); } - return unique_ptr_return_type( - std::move(data).template static_cast_>(), - {std::move(*this)}); + if constexpr (std::is_const_v) + { + void const *raw_ptr = data.get(); + return unique_ptr_return_type( + auxiliary::WriteBuffer( + std::shared_ptr( + raw_ptr, + [data_lambda = + std::move(data)](auto const *) { /* no-op */ })), + determineDatatype>(), + {std::move(*this)}); + } + else + { + return unique_ptr_return_type( + auxiliary::WriteBuffer( + std::move(data).template static_cast_()), + determineDatatype>(), + {std::move(*this)}); + } } template auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type @@ -40,7 +61,12 @@ auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type "Unallocated pointer passed during chunk store."); } return shared_ptr_return_type( - auxiliary::shareRaw(data), {std::move(*this)}); + auxiliary::WriteBuffer( + std::static_pointer_cast< + std::conditional_t, void const, void>>( + auxiliary::shareRaw(data))), + determineDatatype>(), + {std::move(*this)}); } template diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index 644e7acd2b..cdbb75d06e 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -108,9 +108,7 @@ namespace internal namespace core { class ConfigureLoadStore; - template class ConfigureLoadStoreFromBuffer; - template class ConfigureStoreChunkFromBuffer; struct VisitorEnqueueLoadVariant; struct VisitorLoadVariant; @@ -138,9 +136,7 @@ class RecordComponent : public BaseRecordComponent template friend T &internal::makeOwning(T &self, Series); friend class core::ConfigureLoadStore; - template friend class core::ConfigureLoadStoreFromBuffer; - template friend class core::ConfigureStoreChunkFromBuffer; friend struct core::VisitorEnqueueLoadVariant; friend struct core::VisitorLoadVariant; @@ -495,6 +491,10 @@ class RecordComponent : public BaseRecordComponent template void loadChunk_impl(std::shared_ptr, internal::LoadStoreConfigWithBuffer); + void loadChunk_impl( + std::shared_ptr const &, + Datatype, + internal::LoadStoreConfigWithBuffer); template std::shared_ptr loadChunkAllocate_impl(internal::LoadStoreConfig); diff --git a/include/openPMD/auxiliary/Memory.hpp b/include/openPMD/auxiliary/Memory.hpp index 6f8807b354..61be9b9984 100644 --- a/include/openPMD/auxiliary/Memory.hpp +++ b/include/openPMD/auxiliary/Memory.hpp @@ -65,6 +65,7 @@ namespace auxiliary [[nodiscard]] auto release() -> UniquePtrWithLambda; }; using SharedPtr = std::shared_ptr; + using ReadSharedPtr = std::shared_ptr; /* * Use std::any publically since some compilers have trouble with * certain uses of std::variant, so hide it from them. @@ -73,16 +74,20 @@ namespace auxiliary */ std::any m_buffer; - WriteBuffer(); - WriteBuffer(std::shared_ptr ptr); - WriteBuffer(UniquePtrWithLambda ptr); + explicit WriteBuffer(); + // @todo implementation must distinguish const types + template + explicit WriteBuffer(std::shared_ptr ptr); + explicit WriteBuffer(UniquePtrWithLambda ptr); WriteBuffer(WriteBuffer &&) noexcept; WriteBuffer(WriteBuffer const &) = delete; WriteBuffer &operator=(WriteBuffer &&) noexcept; WriteBuffer &operator=(WriteBuffer const &) = delete; - WriteBuffer const &operator=(std::shared_ptr ptr); + // @todo implementation must distinguish const types + template + WriteBuffer const &operator=(std::shared_ptr const &ptr); WriteBuffer const &operator=(UniquePtrWithLambda ptr); void const *get() const; diff --git a/include/openPMD/auxiliary/Memory_internal.hpp b/include/openPMD/auxiliary/Memory_internal.hpp index bf3c8ccb4b..ee7134d9dc 100644 --- a/include/openPMD/auxiliary/Memory_internal.hpp +++ b/include/openPMD/auxiliary/Memory_internal.hpp @@ -25,6 +25,8 @@ namespace openPMD::auxiliary { // cannot use a unique_ptr inside a std::variant, so we represent it with this -using WriteBufferTypes = - std::variant; +using WriteBufferTypes = std::variant< + WriteBuffer::CopyableUniquePtr, + WriteBuffer::SharedPtr, + WriteBuffer::ReadSharedPtr>; } // namespace openPMD::auxiliary diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp index 997dcb537c..802cfeb3c3 100644 --- a/src/IO/ADIOS/ADIOS2File.cpp +++ b/src/IO/ADIOS/ADIOS2File.cpp @@ -106,7 +106,9 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp) std::visit( [&](auto &&arg) { using ptr_type = std::decay_t; - if constexpr (std::is_same_v>) + if constexpr ( + std::is_same_v> || + std::is_same_v>) { auto ptr = static_cast(arg.get()); auto &engine = ba.getEngine(); diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 1ee646948b..40c942c049 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -5,6 +5,7 @@ #include "openPMD/RecordComponent.hpp" #include "openPMD/Span.hpp" #include "openPMD/auxiliary/Memory.hpp" +#include "openPMD/auxiliary/Memory_internal.hpp" #include "openPMD/auxiliary/ShareRawInternal.hpp" #include "openPMD/auxiliary/TypeTraits.hpp" #include "openPMD/auxiliary/UniquePtr.hpp" @@ -208,40 +209,31 @@ namespace core return res; } - template - ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( - Ptr_Type buffer, ConfigureLoadStore &&core) + ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer buffer, Datatype, ConfigureLoadStore &&core) : ConfigureLoadStore(std::move(core)), m_buffer(std::move(buffer)) {} - template - auto ConfigureStoreChunkFromBuffer::storeChunkConfig() + auto ConfigureStoreChunkFromBuffer::storeChunkConfig() -> internal::LoadStoreConfigWithBuffer { return internal::LoadStoreConfigWithBuffer{ this->getOffset(), this->getExtent(), m_mem_select}; } - template - auto ConfigureStoreChunkFromBuffer::enqueueStore() + auto ConfigureStoreChunkFromBuffer::enqueueStore() -> auxiliary::DeferredComputation { this->m_rc.storeChunk_impl( - asWriteBuffer(std::move(m_buffer)), - determineDatatype>(), - storeChunkConfig()); + std::move(m_buffer), m_datatype, storeChunkConfig()); return auxiliary::DeferredComputation( [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); } - template - auto ConfigureStoreChunkFromBuffer::store(EnqueuePolicy ep) - -> void + auto ConfigureStoreChunkFromBuffer::store(EnqueuePolicy ep) -> void { this->m_rc.storeChunk_impl( - asWriteBuffer(std::move(m_buffer)), - determineDatatype>(), - storeChunkConfig()); + std::move(m_buffer), m_datatype, storeChunkConfig()); switch (ep) { case EnqueuePolicy::Defer: @@ -252,31 +244,37 @@ namespace core } } - template - auto ConfigureLoadStoreFromBuffer::enqueueLoad() + auto ConfigureLoadStoreFromBuffer::enqueueLoad() -> auxiliary::DeferredComputation { - static_assert( - std::is_same_v< - Ptr_Type, - std::shared_ptr< - std::remove_cv_t>>, - "ConfigureLoadStoreFromBuffer must be instantiated with a " - "non-const " - "shared_ptr type."); + auto *shared_ptr = std::get_if( + &this->m_buffer.as_variant()); + if (!shared_ptr) + { + throw std::runtime_error( + "ConfigureLoadStoreFromBuffer must be instantiated with a " + "non-const shared_ptr type."); + } this->m_rc.loadChunk_impl( - std::move(this->m_buffer), this->storeChunkConfig()); + *shared_ptr, m_datatype, this->storeChunkConfig()); return auxiliary::DeferredComputation( [dflush = this->deferFlush(this->m_rc)]() mutable -> void { dflush(); }); } - template - auto ConfigureLoadStoreFromBuffer::load(EnqueuePolicy ep) -> void + auto ConfigureLoadStoreFromBuffer::load(EnqueuePolicy ep) -> void { + auto *shared_ptr = std::get_if( + &this->m_buffer.as_variant()); + if (!shared_ptr) + { + throw std::runtime_error( + "ConfigureLoadStoreFromBuffer must be instantiated with a " + "non-const shared_ptr type."); + } this->m_rc.loadChunk_impl( - std::move(this->m_buffer), this->storeChunkConfig()); + *shared_ptr, m_datatype, this->storeChunkConfig()); switch (ep) { @@ -341,39 +339,7 @@ OPENPMD_FOREACH_DATASET_DATATYPE( #undef INSTANTIATE_METHOD_TEMPLATES #undef INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT -#define INSTANTIATE_HALF(pointer_type) \ - template class OPENPMD_APPLY_TEMPLATE( \ - ConfigureStoreChunkFromBuffer, pointer_type); \ - template class core::OPENPMD_APPLY_TEMPLATE( \ - ConfigureStoreChunkFromBuffer, pointer_type); \ - template class compose::ConfigureLoadStore; \ - template class compose::ConfigureStoreChunkFromBuffer< \ - OPENPMD_APPLY_TEMPLATE(ConfigureStoreChunkFromBuffer, pointer_type)>; - -#define INSTANTIATE_FULL(pointer_type) \ - INSTANTIATE_HALF(pointer_type) \ - template class OPENPMD_APPLY_TEMPLATE( \ - ConfigureLoadStoreFromBuffer, pointer_type); \ - template class core::OPENPMD_APPLY_TEMPLATE( \ - ConfigureLoadStoreFromBuffer, pointer_type); \ - template class compose::ConfigureLoadStore; \ - template class compose::ConfigureStoreChunkFromBuffer< \ - OPENPMD_APPLY_TEMPLATE(ConfigureLoadStoreFromBuffer, pointer_type)>; - -#define INSTANTIATE_STORE_CHUNK_FROM_BUFFER(dtype) \ - INSTANTIATE_FULL(std::shared_ptr) \ - INSTANTIATE_HALF(std::shared_ptr) \ - INSTANTIATE_HALF(UniquePtrWithLambda) \ - INSTANTIATE_HALF(UniquePtrWithLambda) - -OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER) - -#undef INSTANTIATE_STORE_CHUNK_FROM_BUFFER #undef INSTANTIATE_METHOD_TEMPLATES -#undef INSTANTIATE_FULL -#undef INSTANTIATE_HALF #undef OPENPMD_ARRAY #undef OPENPMD_APPLY_TEMPLATE diff --git a/src/auxiliary/Memory.cpp b/src/auxiliary/Memory.cpp index c2a0f2aa0d..82cb53de7f 100644 --- a/src/auxiliary/Memory.cpp +++ b/src/auxiliary/Memory.cpp @@ -21,8 +21,10 @@ #include "openPMD/auxiliary/Memory.hpp" #include "openPMD/ChunkInfo.hpp" +#include "openPMD/Datatype.tpp" #include "openPMD/auxiliary/Memory_internal.hpp" #include "openPMD/auxiliary/UniquePtr.hpp" +#include "openPMD/backend/Variant_internal.hpp" #include #include @@ -193,8 +195,21 @@ auto WriteBuffer::CopyableUniquePtr::release() -> UniquePtrWithLambda WriteBuffer::WriteBuffer() : m_buffer(std::make_any()) {} -WriteBuffer::WriteBuffer(std::shared_ptr ptr) - : m_buffer(std::make_any(std::move(ptr))) +template +WriteBuffer::WriteBuffer(std::shared_ptr ptr) + : m_buffer //(std::make_any(std::move(ptr))) + ([&]() { + if constexpr (std::is_const_v) + { + return std::make_any( + std::static_pointer_cast(ptr)); + } + else + { + return std::make_any( + std::static_pointer_cast(ptr)); + } + }()) {} WriteBuffer::WriteBuffer(UniquePtrWithLambda ptr) : m_buffer( @@ -204,9 +219,19 @@ WriteBuffer::WriteBuffer(UniquePtrWithLambda ptr) WriteBuffer::WriteBuffer(WriteBuffer &&) noexcept = default; WriteBuffer &WriteBuffer::operator=(WriteBuffer &&) noexcept = default; -WriteBuffer const &WriteBuffer::operator=(std::shared_ptr ptr) +template +WriteBuffer const &WriteBuffer::operator=(std::shared_ptr const &ptr) { - m_buffer = std::make_any(std::move(ptr)); + if constexpr (std::is_const_v) + { + m_buffer = std::make_any( + std::static_pointer_cast(ptr)); + } + else + { + m_buffer = std::make_any( + std::static_pointer_cast(ptr)); + } return *this; } WriteBuffer const &WriteBuffer::operator=(UniquePtrWithLambda ptr) @@ -226,4 +251,12 @@ void const *WriteBuffer::get() const }, as_variant()); } + +#define OPENPMD_INSTANTIATE(dtype) \ + template WriteBuffer::WriteBuffer(std::shared_ptr); \ + template WriteBuffer const &WriteBuffer::operator=( \ + std::shared_ptr const &); + +OPENPMD_FOREACH_DATASET_DATATYPE(OPENPMD_INSTANTIATE) +#undef OPENPMD_INSTANTIATE } // namespace openPMD::auxiliary From f220a849843d87e6c077a4b4b68cc32d11ef7af0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 9 Feb 2026 17:08:50 +0100 Subject: [PATCH 17/47] Continue --- include/openPMD/Datatype.tpp | 50 ++++++++++++------- include/openPMD/RecordComponent.hpp | 4 +- src/LoadStoreChunk.cpp | 3 ++ src/RecordComponent.cpp | 75 +++++++++++++++-------------- src/auxiliary/Memory.cpp | 11 +++++ 5 files changed, 89 insertions(+), 54 deletions(-) diff --git a/include/openPMD/Datatype.tpp b/include/openPMD/Datatype.tpp index e35f2e26b6..0c8fcbdb47 100644 --- a/include/openPMD/Datatype.tpp +++ b/include/openPMD/Datatype.tpp @@ -223,36 +223,52 @@ namespace detail template constexpr bool is_char_v = is_char::value; - template - inline bool isSameChar() + struct IsChar { - return - // both must be char types - is_char_v && is_char_v && - // both must have equivalent sign - std::is_signed_v == std::is_signed_v && - // both must have equivalent size - sizeof(T_Char1) == sizeof(T_Char2); + template + static constexpr bool call() + { + return is_char_v; + } + template + static constexpr bool call() + { + return false; + } + }; + + constexpr inline bool isChar(Datatype dtype) + { + return switchType(dtype); } - template - struct IsSameChar + struct DtypeSize { - template - static bool call() + template + static constexpr size_t call() { - return isSameChar(); + return sizeof(T); } - - static constexpr char const *errorMsg = "IsSameChar"; + static constexpr char const *errorMsg = "DtypeSize"; }; + constexpr inline size_t dtypeSize(Datatype dtype) + { + return switchType(dtype); + } } // namespace detail template constexpr inline bool isSameChar(Datatype d) { - return switchType>(d); + return isSameChar(d, determineDatatype()); +} + +constexpr bool isSameChar(Datatype d1, Datatype d2) +{ + return detail::isChar(d1) && detail::isChar(d2) && + isSigned(d1) == isSigned(d2) && + detail::dtypeSize(d1) == detail::dtypeSize(d2); } namespace detail diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index cdbb75d06e..abe047cf55 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -489,8 +489,8 @@ class RecordComponent : public BaseRecordComponent internal::LoadStoreConfig, F &&createBuffer); template - void - loadChunk_impl(std::shared_ptr, internal::LoadStoreConfigWithBuffer); + void loadChunk_impl( + std::shared_ptr const &, internal::LoadStoreConfigWithBuffer); void loadChunk_impl( std::shared_ptr const &, Datatype, diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 40c942c049..b0063700c3 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -316,6 +316,9 @@ namespace compose } // namespace compose template class compose::ConfigureLoadStore; +template class compose::ConfigureLoadStore; +template class compose::ConfigureStoreChunkFromBuffer< + ConfigureLoadStoreFromBuffer>; // need this for clang-tidy #define OPENPMD_ARRAY(type) type[] diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index b68714e1b8..d74d56bcc7 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -859,29 +859,53 @@ std::shared_ptr RecordComponent::loadChunk(Offset o, Extent e) namespace detail { - template - struct do_convert + struct FillBuffer { - template - static std::optional call(Attribute &attr) + template + static void call( + void *target, + size_t numPoints, + RecordComponent const &component, + internal::RecordComponentData const &rc) { - if constexpr (std::is_convertible_v) + std::optional val = rc.m_constantValue.getOptional(); + + if (val.has_value()) { - return std::make_optional(attr.get()); + auto raw_ptr = static_cast(target); + std::fill(raw_ptr, raw_ptr + numPoints, *val); } else { - return std::nullopt; + std::string const data_type_str = + datatypeToString(component.getDatatype()); + std::string const requ_type_str = + datatypeToString(determineDatatype()); + std::string err_msg = + "Type conversion during chunk loading not possible! "; + err_msg += + "Data: " + data_type_str + "; Load as: " + requ_type_str; + throw error::WrongAPIUsage(err_msg); } } - static constexpr char const *errorMsg = "is_conversible"; + static constexpr char const *errorMsg = "FillBuffer"; }; } // namespace detail -template +template void RecordComponent::loadChunk_impl( - std::shared_ptr data, + std::shared_ptr const &data, internal::LoadStoreConfigWithBuffer cfg) +{ + loadChunk_impl( + std::static_pointer_cast(data), + determineDatatype>>(), + std::move(cfg)); +} + +void RecordComponent::loadChunk_impl( + std::shared_ptr const &data, + Datatype dtype_requested, internal::LoadStoreConfigWithBuffer cfg) { if (cfg.memorySelection.has_value()) @@ -889,8 +913,6 @@ void RecordComponent::loadChunk_impl( throw error::WrongAPIUsage( "Unsupported: Memory selections in chunk loading."); } - using T = std::remove_cv_t>; - Datatype dtype = determineDatatype(data); /* * For constant components, we implement type conversion, so there is * a separate check further below. @@ -901,11 +923,10 @@ void RecordComponent::loadChunk_impl( * * Attention: Do NOT use operator==(), doesnt work properly on Windows! */ - if (!isSame(dtype, getDatatype()) && !constant()) + if (!isSame(dtype_requested, getDatatype()) && !constant()) { std::string const data_type_str = datatypeToString(getDatatype()); - std::string const requ_type_str = - datatypeToString(determineDatatype()); + std::string const requ_type_str = datatypeToString(dtype_requested); std::string err_msg = "Type conversion during chunk loading not yet implemented! "; err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; @@ -940,25 +961,8 @@ void RecordComponent::loadChunk_impl( for (auto const &dimensionSize : extent) numPoints *= dimensionSize; - std::optional val = - switchNonVectorType>( - /* dt = */ getDatatype(), rc.m_constantValue); - - if (val.has_value()) - { - auto raw_ptr = static_cast(data.get()); - std::fill(raw_ptr, raw_ptr + numPoints, *val); - } - else - { - std::string const data_type_str = datatypeToString(getDatatype()); - std::string const requ_type_str = - datatypeToString(determineDatatype()); - std::string err_msg = - "Type conversion during chunk loading not possible! "; - err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; - throw error::WrongAPIUsage(err_msg); - } + switchDatasetType( + dtype_requested, data.get(), numPoints, *this, rc); } else { @@ -1076,7 +1080,8 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const template void RecordComponent::storeChunk( \ UniquePtrWithLambda data, Offset o, Extent e); \ template void RecordComponent::loadChunk_impl( \ - std::shared_ptr data, internal::LoadStoreConfigWithBuffer cfg); \ + std::shared_ptr const &data, \ + internal::LoadStoreConfigWithBuffer cfg); \ template std::shared_ptr RecordComponent::loadChunkAllocate_impl( \ internal::LoadStoreConfig cfg); diff --git a/src/auxiliary/Memory.cpp b/src/auxiliary/Memory.cpp index 82cb53de7f..5abf0d8063 100644 --- a/src/auxiliary/Memory.cpp +++ b/src/auxiliary/Memory.cpp @@ -257,6 +257,17 @@ void const *WriteBuffer::get() const template WriteBuffer const &WriteBuffer::operator=( \ std::shared_ptr const &); +// currently not instantiating types, this class is internal and we +// dont need it OPENPMD_FOREACH_DATASET_DATATYPE(OPENPMD_INSTANTIATE) +template WriteBuffer::WriteBuffer(std::shared_ptr); +template WriteBuffer const & +WriteBuffer::operator=(std::shared_ptr const &); +template WriteBuffer::WriteBuffer(std::shared_ptr); +template WriteBuffer const & +WriteBuffer::operator=(std::shared_ptr const &); + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + #undef OPENPMD_INSTANTIATE } // namespace openPMD::auxiliary From a548d69a93eaeddd55ed46c75819c56901e88a2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 9 Feb 2026 17:25:23 +0100 Subject: [PATCH 18/47] Mostly working again --- include/openPMD/LoadStoreChunk.tpp | 11 +++++++---- src/LoadStoreChunk.cpp | 6 ++++-- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp index 4d0f1e4aa8..038f9d32df 100644 --- a/include/openPMD/LoadStoreChunk.tpp +++ b/include/openPMD/LoadStoreChunk.tpp @@ -8,6 +8,7 @@ template auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) -> shared_ptr_return_type { + using T_decayed = std::remove_cv_t>; if (!data) { throw std::runtime_error( @@ -18,7 +19,7 @@ auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) std::static_pointer_cast< std::conditional_t, void const, void>>( std::move(data))), - determineDatatype>(), + determineDatatype(), {std::move(*this)}); } template @@ -26,6 +27,7 @@ auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) -> unique_ptr_return_type { + using T_decayed = std::remove_cv_t>; if (!data) { throw std::runtime_error( @@ -40,7 +42,7 @@ auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) raw_ptr, [data_lambda = std::move(data)](auto const *) { /* no-op */ })), - determineDatatype>(), + determineDatatype(), {std::move(*this)}); } else @@ -48,13 +50,14 @@ auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) return unique_ptr_return_type( auxiliary::WriteBuffer( std::move(data).template static_cast_()), - determineDatatype>(), + determineDatatype(), {std::move(*this)}); } } template auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type { + using T_decayed = std::remove_cv_t>; if (!data) { throw std::runtime_error( @@ -65,7 +68,7 @@ auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type std::static_pointer_cast< std::conditional_t, void const, void>>( auxiliary::shareRaw(data))), - determineDatatype>(), + determineDatatype(), {std::move(*this)}); } diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index b0063700c3..24ac318df4 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -210,8 +210,10 @@ namespace core } ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer buffer, Datatype, ConfigureLoadStore &&core) - : ConfigureLoadStore(std::move(core)), m_buffer(std::move(buffer)) + auxiliary::WriteBuffer buffer, Datatype dt, ConfigureLoadStore &&core) + : ConfigureLoadStore(std::move(core)) + , m_buffer(std::move(buffer)) + , m_datatype(dt) {} auto ConfigureStoreChunkFromBuffer::storeChunkConfig() From 5b18268b741b615f063d196c8f67cfc26f85f79e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 9 Feb 2026 17:44:19 +0100 Subject: [PATCH 19/47] bad fix, remove the bool from python bindings --- include/openPMD/auxiliary/Memory.hpp | 4 ++-- src/auxiliary/Memory.cpp | 15 ++++++--------- 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/include/openPMD/auxiliary/Memory.hpp b/include/openPMD/auxiliary/Memory.hpp index 61be9b9984..99b6b53d22 100644 --- a/include/openPMD/auxiliary/Memory.hpp +++ b/include/openPMD/auxiliary/Memory.hpp @@ -87,8 +87,8 @@ namespace auxiliary // @todo implementation must distinguish const types template - WriteBuffer const &operator=(std::shared_ptr const &ptr); - WriteBuffer const &operator=(UniquePtrWithLambda ptr); + WriteBuffer &operator=(std::shared_ptr const &ptr); + WriteBuffer &operator=(UniquePtrWithLambda ptr); void const *get() const; diff --git a/src/auxiliary/Memory.cpp b/src/auxiliary/Memory.cpp index 5abf0d8063..72014f8cd1 100644 --- a/src/auxiliary/Memory.cpp +++ b/src/auxiliary/Memory.cpp @@ -220,7 +220,7 @@ WriteBuffer::WriteBuffer(WriteBuffer &&) noexcept = default; WriteBuffer &WriteBuffer::operator=(WriteBuffer &&) noexcept = default; template -WriteBuffer const &WriteBuffer::operator=(std::shared_ptr const &ptr) +WriteBuffer &WriteBuffer::operator=(std::shared_ptr const &ptr) { if constexpr (std::is_const_v) { @@ -234,7 +234,7 @@ WriteBuffer const &WriteBuffer::operator=(std::shared_ptr const &ptr) } return *this; } -WriteBuffer const &WriteBuffer::operator=(UniquePtrWithLambda ptr) +WriteBuffer &WriteBuffer::operator=(UniquePtrWithLambda ptr) { m_buffer = std::make_any(CopyableUniquePtr(std::move(ptr))); @@ -254,17 +254,14 @@ void const *WriteBuffer::get() const #define OPENPMD_INSTANTIATE(dtype) \ template WriteBuffer::WriteBuffer(std::shared_ptr); \ - template WriteBuffer const &WriteBuffer::operator=( \ + template WriteBuffer &WriteBuffer::operator=( \ std::shared_ptr const &); -// currently not instantiating types, this class is internal and we -// dont need it -OPENPMD_FOREACH_DATASET_DATATYPE(OPENPMD_INSTANTIATE) +OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE) template WriteBuffer::WriteBuffer(std::shared_ptr); -template WriteBuffer const & -WriteBuffer::operator=(std::shared_ptr const &); +template WriteBuffer &WriteBuffer::operator=(std::shared_ptr const &); template WriteBuffer::WriteBuffer(std::shared_ptr); -template WriteBuffer const & +template WriteBuffer & WriteBuffer::operator=(std::shared_ptr const &); #endif /* DOXYGEN_SHOULD_SKIP_THIS */ From c232412d8a6493fb2b83fdc1056abbe096d2a499 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 9 Feb 2026 19:16:44 +0100 Subject: [PATCH 20/47] Remove bool dataset operations from python API --- src/auxiliary/Memory.cpp | 4 +++- src/binding/python/PatchRecordComponent.cpp | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/auxiliary/Memory.cpp b/src/auxiliary/Memory.cpp index 72014f8cd1..b002288a88 100644 --- a/src/auxiliary/Memory.cpp +++ b/src/auxiliary/Memory.cpp @@ -257,7 +257,9 @@ void const *WriteBuffer::get() const template WriteBuffer &WriteBuffer::operator=( \ std::shared_ptr const &); -OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE) +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +OPENPMD_FOREACH_DATASET_DATATYPE(OPENPMD_INSTANTIATE) template WriteBuffer::WriteBuffer(std::shared_ptr); template WriteBuffer &WriteBuffer::operator=(std::shared_ptr const &); template WriteBuffer::WriteBuffer(std::shared_ptr); diff --git a/src/binding/python/PatchRecordComponent.cpp b/src/binding/python/PatchRecordComponent.cpp index 5887ba7d03..c68cdbc16f 100644 --- a/src/binding/python/PatchRecordComponent.cpp +++ b/src/binding/python/PatchRecordComponent.cpp @@ -130,7 +130,9 @@ void init_PatchRecordComponent(py::module &m) switch (dtype) { case DT::BOOL: - return prc.store(idx, *static_cast(buf.ptr)); + throw std::runtime_error( + "make_constant: " + "Boolean type not supported!"); break; case DT::SHORT: return prc.store(idx, *static_cast(buf.ptr)); From 54ab213c9251bf96dd13743f65bd88a474f761b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 9 Feb 2026 19:25:04 +0100 Subject: [PATCH 21/47] Fix Coretest --- test/CoreTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp index 8a2be5f27c..903363538d 100644 --- a/test/CoreTest.cpp +++ b/test/CoreTest.cpp @@ -1270,7 +1270,7 @@ TEST_CASE("use_count_test", "[core]") pprc.resetDataset(Dataset(determineDatatype(), {4})); pprc.store(0, static_cast(1)); REQUIRE( - std::get>( + std::get>( static_cast *>( pprc.get().m_chunks.front().parameter.get()) ->data.as_variant()) From dcc6663221be399e2879431622afdd6fdbf87afd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 10 Feb 2026 11:55:32 +0100 Subject: [PATCH 22/47] instantiate some more methods --- include/openPMD/LoadStoreChunk.tpp | 68 ----------------------- src/LoadStoreChunk.cpp | 87 +++++++++++++++++++++++++++++- 2 files changed, 86 insertions(+), 69 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp index 038f9d32df..8799124a90 100644 --- a/include/openPMD/LoadStoreChunk.tpp +++ b/include/openPMD/LoadStoreChunk.tpp @@ -4,74 +4,6 @@ namespace openPMD::core { -template -auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) - -> shared_ptr_return_type -{ - using T_decayed = std::remove_cv_t>; - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - return shared_ptr_return_type( - auxiliary::WriteBuffer( - std::static_pointer_cast< - std::conditional_t, void const, void>>( - std::move(data))), - determineDatatype(), - {std::move(*this)}); -} -template -auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) - -> unique_ptr_return_type - -{ - using T_decayed = std::remove_cv_t>; - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - if constexpr (std::is_const_v) - { - void const *raw_ptr = data.get(); - return unique_ptr_return_type( - auxiliary::WriteBuffer( - std::shared_ptr( - raw_ptr, - [data_lambda = - std::move(data)](auto const *) { /* no-op */ })), - determineDatatype(), - {std::move(*this)}); - } - else - { - return unique_ptr_return_type( - auxiliary::WriteBuffer( - std::move(data).template static_cast_()), - determineDatatype(), - {std::move(*this)}); - } -} -template -auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type -{ - using T_decayed = std::remove_cv_t>; - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - return shared_ptr_return_type( - auxiliary::WriteBuffer( - std::static_pointer_cast< - std::conditional_t, void const, void>>( - auxiliary::shareRaw(data))), - determineDatatype(), - {std::move(*this)}); -} - template auto ConfigureLoadStore::withUniquePtr(std::unique_ptr data) -> unique_ptr_return_type diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 24ac318df4..31390294dc 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -123,6 +123,74 @@ namespace core return *m_extent; } + template + auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) + -> shared_ptr_return_type + { + using T_decayed = std::remove_cv_t>; + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return shared_ptr_return_type( + auxiliary::WriteBuffer( + std::static_pointer_cast< + std::conditional_t, void const, void>>( + std::move(data))), + determineDatatype(), + {std::move(*this)}); + } + template + auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) + -> unique_ptr_return_type + + { + using T_decayed = std::remove_cv_t>; + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + if constexpr (std::is_const_v) + { + void const *raw_ptr = data.get(); + return unique_ptr_return_type( + auxiliary::WriteBuffer( + std::shared_ptr( + raw_ptr, + [data_lambda = + std::move(data)](auto const *) { /* no-op */ })), + determineDatatype(), + {std::move(*this)}); + } + else + { + return unique_ptr_return_type( + auxiliary::WriteBuffer( + std::move(data).template static_cast_()), + determineDatatype(), + {std::move(*this)}); + } + } + template + auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type + { + using T_decayed = std::remove_cv_t>; + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return shared_ptr_return_type( + auxiliary::WriteBuffer( + std::static_pointer_cast< + std::conditional_t, void const, void>>( + auxiliary::shareRaw(data))), + determineDatatype(), + {std::move(*this)}); + } + template auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView { @@ -324,6 +392,7 @@ template class compose::ConfigureStoreChunkFromBuffer< // need this for clang-tidy #define OPENPMD_ARRAY(type) type[] +#define OPENPMD_POINTER(type) type * #define OPENPMD_APPLY_TEMPLATE(template_, type) template_ #define INSTANTIATE_METHOD_TEMPLATES(dtype) \ @@ -332,11 +401,26 @@ template class compose::ConfigureStoreChunkFromBuffer< std::shared_ptr, dtype)>; \ template auto core::ConfigureLoadStore::load(EnqueuePolicy) \ ->std::shared_ptr; +#define INSTANTIATE_FULLMATRIX(dtype) \ + template auto core::ConfigureLoadStore::withSharedPtr( \ + std::shared_ptr data) -> shared_ptr_return_type; \ + template auto core::ConfigureLoadStore::withUniquePtr( \ + UniquePtrWithLambda data) -> unique_ptr_return_type; #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type)) \ + INSTANTIATE_FULLMATRIX(type) \ + INSTANTIATE_FULLMATRIX(type const) \ + INSTANTIATE_FULLMATRIX(OPENPMD_ARRAY(type)) \ + INSTANTIATE_FULLMATRIX(OPENPMD_ARRAY(type const)) \ template auto core::ConfigureLoadStore::enqueueStore() \ - -> DynamicMemoryView; + -> DynamicMemoryView; \ + template auto core::ConfigureLoadStore::withRawPtr(OPENPMD_POINTER(type) \ + data) \ + ->OPENPMD_APPLY_TEMPLATE(shared_ptr_return_type, type); \ + template auto core::ConfigureLoadStore::withRawPtr( \ + OPENPMD_POINTER(type const) data) \ + ->OPENPMD_APPLY_TEMPLATE(shared_ptr_return_type, type const); OPENPMD_FOREACH_DATASET_DATATYPE( INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) @@ -346,6 +430,7 @@ OPENPMD_FOREACH_DATASET_DATATYPE( #undef INSTANTIATE_METHOD_TEMPLATES #undef OPENPMD_ARRAY +#undef OPENPMD_POINTER #undef OPENPMD_APPLY_TEMPLATE ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) From 2496991c6b46eb9ed2c2ac2ba7b956221c2d2a7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 10 Feb 2026 15:08:10 +0100 Subject: [PATCH 23/47] wip: unify common code into compiled functions --- include/openPMD/LoadStoreChunk.hpp | 22 ++++- include/openPMD/RecordComponent.hpp | 2 + src/LoadStoreChunk.cpp | 143 +++++++++++++++++++++------- src/RecordComponent.cpp | 30 +++--- src/auxiliary/UniquePtr.cpp | 3 +- 5 files changed, 147 insertions(+), 53 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index dd98d9fb51..60d994ce5f 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -76,6 +76,7 @@ namespace core friend class compose::ConfigureLoadStore; template friend class compose::ConfigureLoadStoreFromBuffer; + friend class openPMD::RecordComponent; protected: ConfigureLoadStore(RecordComponent &); @@ -89,6 +90,21 @@ namespace core auto deferFlush(Attributable &); + private: + auto withSharedPtr_impl_mut(std::shared_ptr data, Datatype) + -> openPMD::ConfigureLoadStoreFromBuffer; + auto + withSharedPtr_impl_const(std::shared_ptr data, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + auto withUniquePtr_impl_mut(UniquePtrWithLambda, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + auto withUniquePtr_impl_const(UniquePtrWithLambda, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + auto withRawPtr_impl_mut(void *data, Datatype) + -> openPMD::ConfigureLoadStoreFromBuffer; + auto withRawPtr_impl_const(void const *data, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + public: auto getOffset() -> Offset const &; auto getExtent() -> Extent const &; @@ -99,7 +115,7 @@ namespace core template struct shared_ptr_return_type_impl { - using return_type = ConfigureLoadStoreFromBuffer; + using return_type = openPMD::ConfigureLoadStoreFromBuffer; using normalize_pointer_type = std::shared_ptr>; }; @@ -110,7 +126,7 @@ namespace core template struct shared_ptr_return_type_impl { - using return_type = ConfigureStoreChunkFromBuffer; + using return_type = openPMD::ConfigureStoreChunkFromBuffer; using normalize_pointer_type = std::shared_ptr const>; }; @@ -127,7 +143,7 @@ namespace core * simpler for unique pointers. Just remove the array extents here. */ template - using unique_ptr_return_type = ConfigureStoreChunkFromBuffer; + using unique_ptr_return_type = openPMD::ConfigureStoreChunkFromBuffer; template using unique_ptr_normalized_type = UniquePtrWithLambda>; diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index abe047cf55..ea374e9423 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -497,6 +497,8 @@ class RecordComponent : public BaseRecordComponent internal::LoadStoreConfigWithBuffer); template std::shared_ptr loadChunkAllocate_impl(internal::LoadStoreConfig); + std::shared_ptr loadChunkAllocate_impl( + Datatype, size_t dtype_size, internal::LoadStoreConfig); // clang-format off OPENPMD_protected diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 31390294dc..dd81ef4286 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -123,22 +123,86 @@ namespace core return *m_extent; } + auto ConfigureLoadStore::withSharedPtr_impl_mut( + std::shared_ptr data, Datatype datatype) + -> openPMD::ConfigureLoadStoreFromBuffer + { + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return openPMD::ConfigureLoadStoreFromBuffer( + auxiliary::WriteBuffer(std::move(data)), + datatype, + {std::move(*this)}); + } + auto ConfigureLoadStore::withSharedPtr_impl_const( + std::shared_ptr data, Datatype datatype) + -> openPMD::ConfigureStoreChunkFromBuffer + { + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer(std::move(data)), + datatype, + {std::move(*this)}); + } + template auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) -> shared_ptr_return_type { using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) + { + return withSharedPtr_impl_const(data, dtype); + } + else + { + return withSharedPtr_impl_mut(data, dtype); + } + } + + auto ConfigureLoadStore::withUniquePtr_impl_mut( + UniquePtrWithLambda data, Datatype dtype) + -> openPMD::ConfigureStoreChunkFromBuffer + + { + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer(std::move(data)), dtype, {std::move(*this)}); + } + auto ConfigureLoadStore::withUniquePtr_impl_const( + UniquePtrWithLambda data, Datatype dtype) + -> openPMD::ConfigureStoreChunkFromBuffer + + { if (!data) { throw std::runtime_error( "Unallocated pointer passed during chunk store."); } - return shared_ptr_return_type( + + void const *raw_ptr = data.release(); + auto &deleter = data.get_deleter(); + return openPMD::ConfigureStoreChunkFromBuffer( auxiliary::WriteBuffer( - std::static_pointer_cast< - std::conditional_t, void const, void>>( - std::move(data))), - determineDatatype(), + std::shared_ptr( + raw_ptr, + [deleter_lambda = std::move(deleter)](auto const *p) { + deleter_lambda(p); + })), + dtype, {std::move(*this)}); } template @@ -147,50 +211,63 @@ namespace core { using T_decayed = std::remove_cv_t>; - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } + constexpr auto dtype = determineDatatype(); if constexpr (std::is_const_v) { - void const *raw_ptr = data.get(); - return unique_ptr_return_type( - auxiliary::WriteBuffer( - std::shared_ptr( - raw_ptr, - [data_lambda = - std::move(data)](auto const *) { /* no-op */ })), - determineDatatype(), - {std::move(*this)}); + return withUniquePtr_impl_const( + std::move(data).template static_cast_(), dtype); } else { - return unique_ptr_return_type( - auxiliary::WriteBuffer( - std::move(data).template static_cast_()), - determineDatatype(), - {std::move(*this)}); + return withUniquePtr_impl_mut( + std::move(data).template static_cast_(), dtype); } } - template - auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type + + auto ConfigureLoadStore::withRawPtr_impl_mut(void *data, Datatype dtype) + -> openPMD::ConfigureLoadStoreFromBuffer { - using T_decayed = std::remove_cv_t>; if (!data) { throw std::runtime_error( "Unallocated pointer passed during chunk store."); } - return shared_ptr_return_type( - auxiliary::WriteBuffer( - std::static_pointer_cast< - std::conditional_t, void const, void>>( - auxiliary::shareRaw(data))), - determineDatatype(), + return openPMD::ConfigureLoadStoreFromBuffer( + auxiliary::WriteBuffer(auxiliary::shareRaw(data)), + dtype, + {std::move(*this)}); + } + + auto + ConfigureLoadStore::withRawPtr_impl_const(void const *data, Datatype dtype) + -> openPMD::ConfigureStoreChunkFromBuffer + { + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer(auxiliary::shareRaw(data)), + dtype, {std::move(*this)}); } + template + auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type + { + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) + { + return withRawPtr_impl_const(data, dtype); + } + else + { + return withRawPtr_impl_mut(data, dtype); + } + } + template auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView { diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index d74d56bcc7..b92db90c0b 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -229,8 +229,15 @@ template std::shared_ptr RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg) { - using T = std::remove_extent_t; - // static_assert(!std::is_same_v, "EVIL"); + using T = std::remove_cv_t>; + auto res = loadChunkAllocate_impl( + determineDatatype(), sizeof(T), std::move(cfg)); + return std::static_pointer_cast(res); +} + +std::shared_ptr RecordComponent::loadChunkAllocate_impl( + Datatype dtype, size_t dtype_size, internal::LoadStoreConfig cfg) +{ auto [o, e] = std::move(cfg); size_t numPoints = 1; @@ -239,25 +246,16 @@ RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg) numPoints *= val; } -#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) || \ - (defined(__apple_build_version__) && __clang_major__ < 14) - auto newData = std::shared_ptr( - new T[numPoints], [](T *p) { delete[] p; }); + auto newData = + std::shared_ptr(new char[numPoints * dtype_size], [](void *p) { + delete[] (static_cast(p)); + }); prepareLoadStore() .offset(std::move(o)) .extent(std::move(e)) - .withSharedPtr(newData) + .withSharedPtr_impl_mut(newData, dtype) .load(EnqueuePolicy::Defer); return newData; -#else - auto newData = std::shared_ptr(new T[numPoints]); - prepareLoadStore() - .offset(std::move(o)) - .extent(std::move(e)) - .withSharedPtr(newData) - .load(EnqueuePolicy::Defer); - return std::static_pointer_cast(std::move(newData)); -#endif } RecordComponent::RecordComponent() : BaseRecordComponent(NoInit()) diff --git a/src/auxiliary/UniquePtr.cpp b/src/auxiliary/UniquePtr.cpp index 474441fdd3..828c33a785 100644 --- a/src/auxiliary/UniquePtr.cpp +++ b/src/auxiliary/UniquePtr.cpp @@ -58,7 +58,7 @@ namespace auxiliary OPENPMD_FOREACH_DATASET_DATATYPE( OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT) - OPENPMD_INSTANTIATE(void) + OPENPMD_INSTANTIATE(void) OPENPMD_INSTANTIATE(void const) #undef OPENPMD_INSTANTIATE #undef OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT @@ -108,6 +108,7 @@ OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT) // Instantiate this directly, do not instantiate the // `std::unique_ptr`-based constructor. template class UniquePtrWithLambda; +template class UniquePtrWithLambda; #undef OPENPMD_INSTANTIATE #undef OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT #undef OPENPMD_ARRAY From 78887cf05f51bcf6e6d4d13b8dd0e7d5a29968d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 10 Feb 2026 19:26:07 +0100 Subject: [PATCH 24/47] clang-tidy fixes --- src/Series.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Series.cpp b/src/Series.cpp index 038bffc7cc..24529aae19 100644 --- a/src/Series.cpp +++ b/src/Series.cpp @@ -523,12 +523,13 @@ void Series::flushRankTable() }; auto writeDataset = [&rank, &maxSize, this, &rankTable]( - std::shared_ptr put, size_t num_lines = 1) { + std::shared_ptr const &put, + size_t num_lines = 1) { Parameter chunk; chunk.dtype = Datatype::CHAR; chunk.offset = {uint64_t(rank), 0}; chunk.extent = {num_lines, maxSize}; - chunk.data = std::move(put); + chunk.data = put; IOHandler()->enqueue( IOTask(&rankTable.m_attributable, std::move(chunk))); }; From 64f78bf0381d92c87167b8ecec7e046988768956 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Wed, 11 Feb 2026 11:51:04 +0100 Subject: [PATCH 25/47] CI fixes --- src/Series.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Series.cpp b/src/Series.cpp index 24529aae19..14f813559d 100644 --- a/src/Series.cpp +++ b/src/Series.cpp @@ -570,7 +570,7 @@ void Series::flushRankTable() * > } */ [asRawPtr](char *) { delete asRawPtr; }}; - writeDataset(std::move(put), /* num_lines = */ size); + writeDataset(put, /* num_lines = */ size); } // Must ensure that the Writable is consistently set to written on all @@ -589,7 +589,7 @@ void Series::flushRankTable() new char[maxSize]{}, [](char const *ptr) { delete[] ptr; }}; std::copy_n(myRankInfo.c_str(), mySize, put.get()); - writeDataset(std::move(put)); + writeDataset(put); } std::string Series::particlesPath() const From fdec544edd25c2b62d2127b97b50cdf055429ac1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 12 Feb 2026 13:57:29 +0100 Subject: [PATCH 26/47] Remove CRT pattern and core namespace bit of code duplication, but better than CRT complexity --- include/openPMD/LoadStoreChunk.hpp | 447 +++++++-------- include/openPMD/LoadStoreChunk.tpp | 4 +- include/openPMD/RecordComponent.hpp | 19 +- include/openPMD/RecordComponent.tpp | 3 +- include/openPMD/backend/Attributable.hpp | 7 +- src/LoadStoreChunk.cpp | 672 +++++++++++------------ 6 files changed, 537 insertions(+), 615 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 60d994ce5f..53a10544c3 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -3,15 +3,12 @@ #include "openPMD/Dataset.hpp" #include "openPMD/auxiliary/Future.hpp" #include "openPMD/auxiliary/Memory.hpp" -#include "openPMD/auxiliary/ShareRawInternal.hpp" #include "openPMD/auxiliary/UniquePtr.hpp" // comment to prevent this include from being moved by clang-format #include "openPMD/DatatypeMacros.hpp" -#include #include -#include #include namespace openPMD @@ -48,271 +45,245 @@ namespace auxiliary::detail #undef OPENPMD_ENUMERATE_TYPES } // namespace auxiliary::detail -namespace compose -{ - template - class ConfigureLoadStore; - template - class ConfigureLoadStoreFromBuffer; -} // namespace compose - enum class EnqueuePolicy { Defer, Immediate }; -namespace core +/* + * Actual data members of `ConfigureLoadStore<>` and methods that don't + * depend on the ChildClass template parameter. By extracting the members to + * this struct, we can pass them around between different instances of the + * class template. Numbers of method instantiations can be reduced. + */ +class ConfigureLoadStore { + friend class openPMD::RecordComponent; + +protected: + ConfigureLoadStore(RecordComponent &); + RecordComponent &m_rc; + + std::optional m_offset; + std::optional m_extent; + + [[nodiscard]] auto dim() const -> uint8_t; + auto storeChunkConfig() -> internal::LoadStoreConfig; + + auto deferFlush(Attributable &); + + // The below methods return void. + // For chaining calls, they should return *this, but this class right + // here is going to be somewhere in the inheritance chain, and the final + // class should be returned. Could be solved more elegantly with CRT, + // but that blows up compile-time, so we make internal void functions + // and then repeat them in the final classes. + + void offset_impl(Offset); + void extent_impl(Extent); + +private: + auto withSharedPtr_impl_mut(std::shared_ptr data, Datatype) + -> openPMD::ConfigureLoadStoreFromBuffer; + auto withSharedPtr_impl_const(std::shared_ptr data, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + auto withUniquePtr_impl_mut(UniquePtrWithLambda, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + auto withUniquePtr_impl_const(UniquePtrWithLambda, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + auto withRawPtr_impl_mut(void *data, Datatype) + -> openPMD::ConfigureLoadStoreFromBuffer; + auto withRawPtr_impl_const(void const *data, Datatype) + -> openPMD::ConfigureStoreChunkFromBuffer; + +public: + using this_t = ConfigureLoadStore; + + auto getOffset() -> Offset const &; + auto getExtent() -> Extent const &; + + auto offset(Offset offset) -> this_t & + { + offset_impl(std::move(offset)); + return *this; + } + auto extent(Extent extent) -> this_t & + { + extent_impl(std::move(extent)); + return *this; + } /* - * Actual data members of `ConfigureLoadStore<>` and methods that don't - * depend on the ChildClass template parameter. By extracting the members to - * this struct, we can pass them around between different instances of the - * class template. Numbers of method instantiations can be reduced. + * If the type is non-const, then the return type should be + * ConfigureLoadStoreFromBuffer<>, ... */ - class ConfigureLoadStore + template + struct shared_ptr_return_type_impl { - template - friend class compose::ConfigureLoadStore; - template - friend class compose::ConfigureLoadStoreFromBuffer; - friend class openPMD::RecordComponent; - - protected: - ConfigureLoadStore(RecordComponent &); - RecordComponent &m_rc; - - std::optional m_offset; - std::optional m_extent; - - [[nodiscard]] auto dim() const -> uint8_t; - auto storeChunkConfig() -> internal::LoadStoreConfig; - - auto deferFlush(Attributable &); - - private: - auto withSharedPtr_impl_mut(std::shared_ptr data, Datatype) - -> openPMD::ConfigureLoadStoreFromBuffer; - auto - withSharedPtr_impl_const(std::shared_ptr data, Datatype) - -> openPMD::ConfigureStoreChunkFromBuffer; - auto withUniquePtr_impl_mut(UniquePtrWithLambda, Datatype) - -> openPMD::ConfigureStoreChunkFromBuffer; - auto withUniquePtr_impl_const(UniquePtrWithLambda, Datatype) - -> openPMD::ConfigureStoreChunkFromBuffer; - auto withRawPtr_impl_mut(void *data, Datatype) - -> openPMD::ConfigureLoadStoreFromBuffer; - auto withRawPtr_impl_const(void const *data, Datatype) - -> openPMD::ConfigureStoreChunkFromBuffer; - - public: - auto getOffset() -> Offset const &; - auto getExtent() -> Extent const &; - /* - * If the type is non-const, then the return type should be - * ConfigureLoadStoreFromBuffer<>, ... - */ - template - struct shared_ptr_return_type_impl - { - using return_type = openPMD::ConfigureLoadStoreFromBuffer; - using normalize_pointer_type = - std::shared_ptr>; - }; - /* - * ..., but if it is a const type, Load operations make no sense, so the - * return type should be ConfigureStoreChunkFromBuffer<>. - */ - template - struct shared_ptr_return_type_impl - { - using return_type = openPMD::ConfigureStoreChunkFromBuffer; - using normalize_pointer_type = - std::shared_ptr const>; - }; - - template - using shared_ptr_return_type = typename shared_ptr_return_type_impl< - std::remove_extent_t>::return_type; - template - using shared_ptr_normalized_type = typename shared_ptr_return_type_impl< - std::remove_extent_t>::normalized_pointer_type; - - /* - * As loading into unique pointer types makes no sense, the case is - * simpler for unique pointers. Just remove the array extents here. - */ - template - using unique_ptr_return_type = openPMD::ConfigureStoreChunkFromBuffer; - template - using unique_ptr_normalized_type = - UniquePtrWithLambda>; - - // @todo rvalue references..? - template - auto withSharedPtr(std::shared_ptr) -> shared_ptr_return_type; - template - auto withUniquePtr(UniquePtrWithLambda) -> unique_ptr_return_type; - template - auto withUniquePtr(std::unique_ptr) - -> unique_ptr_return_type; - template - auto withRawPtr(T *data) -> shared_ptr_return_type; - template - auto withContiguousContainer(T_ContiguousContainer &data) - -> std::enable_if_t< - auxiliary::IsContiguousContainer_v, - shared_ptr_return_type< - typename T_ContiguousContainer::value_type>>; - - template - [[nodiscard]] auto enqueueStore() -> DynamicMemoryView; - // definition for this one is in RecordComponent.tpp since it needs the - // definition of class RecordComponent. - template - [[nodiscard]] auto enqueueStore(F &&createBuffer) - -> DynamicMemoryView; - - template - [[nodiscard]] auto enqueueLoad() - -> auxiliary::DeferredComputation>; - - template - [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr; - - [[nodiscard]] auto enqueueLoadVariant() - -> auxiliary::DeferredComputation< - auxiliary::detail::shared_ptr_dataset_types>; - - [[nodiscard]] auto loadVariant(EnqueuePolicy) - -> auxiliary::detail::shared_ptr_dataset_types; + using return_type = openPMD::ConfigureLoadStoreFromBuffer; + using normalize_pointer_type = std::shared_ptr>; }; - - class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore + /* + * ..., but if it is a const type, Load operations make no sense, so the + * return type should be ConfigureStoreChunkFromBuffer<>. + */ + template + struct shared_ptr_return_type_impl { - public: - auxiliary::WriteBuffer m_buffer; - Datatype m_datatype; - std::optional m_mem_select; - - ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer buffer, Datatype, ConfigureLoadStore &&); - - auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; - - auto enqueueStore() -> auxiliary::DeferredComputation; - - auto store(EnqueuePolicy) -> void; - - /** This intentionally shadows the parent class's enqueueLoad methods in - * order to show a compile error when using enqueueLoad() on an object - * of this class. The parent method can still be accessed through - * as_parent() if needed. - */ - template - auto enqueueLoad() - { - static_assert( - auxiliary::dependent_false_v, - "Cannot load chunk data into a buffer that is const or a " - "unique_ptr."); - } - - template - auto load(EnqueuePolicy) - { - static_assert( - auxiliary::dependent_false_v, - "Cannot load chunk data into a buffer that is const or a " - "unique_ptr."); - } + using return_type = openPMD::ConfigureStoreChunkFromBuffer; + using normalize_pointer_type = + std::shared_ptr const>; }; - class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer - { - public: - using ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; - - auto enqueueLoad() -> auxiliary::DeferredComputation; + template + using shared_ptr_return_type = typename shared_ptr_return_type_impl< + std::remove_extent_t>::return_type; + template + using shared_ptr_normalized_type = typename shared_ptr_return_type_impl< + std::remove_extent_t>::normalized_pointer_type; - auto load(EnqueuePolicy) -> void; - }; -} // namespace core + /* + * As loading into unique pointer types makes no sense, the case is + * simpler for unique pointers. Just remove the array extents here. + */ + template + using unique_ptr_return_type = openPMD::ConfigureStoreChunkFromBuffer; + + // @todo rvalue references..? + template + auto withSharedPtr(std::shared_ptr) -> shared_ptr_return_type; + template + auto withUniquePtr(UniquePtrWithLambda) -> unique_ptr_return_type; + template + auto withUniquePtr(std::unique_ptr) -> unique_ptr_return_type; + template + auto withRawPtr(T *data) -> shared_ptr_return_type; + template + auto withContiguousContainer(T_ContiguousContainer &data) + -> std::enable_if_t< + auxiliary::IsContiguousContainer_v, + shared_ptr_return_type>; + + template + [[nodiscard]] auto enqueueStore() -> DynamicMemoryView; + // definition for this one is in RecordComponent.tpp since it needs the + // definition of class RecordComponent. + template + [[nodiscard]] auto enqueueStore(F &&createBuffer) -> DynamicMemoryView; + + template + [[nodiscard]] auto enqueueLoad() + -> auxiliary::DeferredComputation>; + + template + [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr; + + [[nodiscard]] auto enqueueLoadVariant() -> auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types>; + + [[nodiscard]] auto loadVariant(EnqueuePolicy) + -> auxiliary::detail::shared_ptr_dataset_types; +}; -namespace compose +class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore { - /** Basic configuration for a Load/Store operation. - * - * @tparam ChildClass CRT pattern. - * The purpose is that in child classes `return *this` should return - * an instance of the child class, not of ConfigureLoadStore. - * Instantiate with void when using without subclass. - */ - template - class ConfigureLoadStore + friend class ConfigureLoadStore; + +protected: + auxiliary::WriteBuffer m_buffer; + Datatype m_datatype; + std::optional m_mem_select; + + ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer buffer, Datatype, ConfigureLoadStore &&); + + // The below methods return void. + // For chaining calls, they should return *this, but this class right + // here is going to be somewhere in the inheritance chain, and the final + // class should be returned. Could be solved more elegantly with CRT, + // but that blows up compile-time, so we make internal void functions + // and then repeat them in the final classes. + void memorySelection_impl(MemorySelection); + +public: + using this_t = ConfigureStoreChunkFromBuffer; + + auto offset(Offset offset) -> this_t & + { + offset_impl(std::move(offset)); + return *this; + } + auto extent(Extent extent) -> this_t & + { + extent_impl(std::move(extent)); + return *this; + } + auto memorySelection(MemorySelection memorySelection) -> this_t & { - ConfigureLoadStore() = default; + memorySelection_impl(std::move(memorySelection)); + return *this; + } - public: - auto offset(Offset) -> ChildClass &; - auto extent(Extent) -> ChildClass &; - friend ChildClass; - }; + auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; + + auto enqueueStore() -> auxiliary::DeferredComputation; - /** Configuration for a Store operation with a buffer type. - * - * This class does intentionally not support Load operations since there are - * pointer types (const pointers, unique pointers) where Load operations - * make no sense. See the \ref ConfigureLoadStoreFromBuffer class template - * for both Load/Store operations. - * - * @tparam Ptr_Type The type of pointer used internally. - * @tparam ChildClass CRT pattern. - * The purpose is that in child classes `return *this` should return - * an instance of the child class, not of - * ConfigureStoreChunkFromBuffer. Instantiate with void when using without - * subclass. + auto store(EnqueuePolicy) -> void; + + /** This intentionally shadows the parent class's enqueueLoad methods in + * order to show a compile error when using load() on an object + * of this class. The parent method can still be accessed through + * typecasting if needed. */ - template - class ConfigureStoreChunkFromBuffer + template + auto enqueueLoad() { - public: - auto memorySelection(MemorySelection) -> ChildClass &; - }; -} // namespace compose + static_assert( + auxiliary::dependent_false_v, + "Cannot load chunk data into a buffer that is const or a " + "unique_ptr."); + } + + template + auto load(EnqueuePolicy) + { + static_assert( + auxiliary::dependent_false_v, + "Cannot load chunk data into a buffer that is const or a " + "unique_ptr."); + } +}; -class ConfigureLoadStore - : public core::ConfigureLoadStore - , public compose::ConfigureLoadStore +class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer { - friend class RecordComponent; - friend class core::ConfigureLoadStore; + friend class ConfigureLoadStore; - ConfigureLoadStore(RecordComponent &rc); - ConfigureLoadStore(core::ConfigureLoadStore &&); -}; + using ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; -class ConfigureStoreChunkFromBuffer - : public core::ConfigureStoreChunkFromBuffer - , public compose::ConfigureLoadStore - , public compose::ConfigureStoreChunkFromBuffer< - ConfigureStoreChunkFromBuffer> -{ - friend class core::ConfigureLoadStore; +public: + using this_t = ConfigureLoadStoreFromBuffer; - using core::ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; -}; + auto offset(Offset offset) -> this_t & + { + offset_impl(std::move(offset)); + return *this; + } + auto extent(Extent extent) -> this_t & + { + extent_impl(std::move(extent)); + return *this; + } + auto memorySelection(MemorySelection memorySelection) -> this_t & + { + memorySelection_impl(std::move(memorySelection)); + return *this; + } -class ConfigureLoadStoreFromBuffer - : public core::ConfigureLoadStoreFromBuffer - , public compose::ConfigureLoadStore - , public compose::ConfigureStoreChunkFromBuffer< - ConfigureLoadStoreFromBuffer> -{ - friend class ConfigureLoadStoreCore; + auto enqueueLoad() -> auxiliary::DeferredComputation; - using core::ConfigureLoadStoreFromBuffer::ConfigureLoadStoreFromBuffer; + auto load(EnqueuePolicy) -> void; }; + } // namespace openPMD #include "openPMD/UndefDatatypeMacros.hpp" diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp index 8799124a90..db24185932 100644 --- a/include/openPMD/LoadStoreChunk.tpp +++ b/include/openPMD/LoadStoreChunk.tpp @@ -2,7 +2,7 @@ #include "openPMD/LoadStoreChunk.hpp" -namespace openPMD::core +namespace openPMD { template auto ConfigureLoadStore::withUniquePtr(std::unique_ptr data) @@ -22,4 +22,4 @@ auto ConfigureLoadStore::withContiguousContainer(T_ContiguousContainer &data) } return withRawPtr(data.data()); } -} // namespace openPMD::core +} // namespace openPMD diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index ea374e9423..3150c94535 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -105,15 +105,6 @@ namespace internal class BaseRecordData; } // namespace internal -namespace core -{ - class ConfigureLoadStore; - class ConfigureLoadStoreFromBuffer; - class ConfigureStoreChunkFromBuffer; - struct VisitorEnqueueLoadVariant; - struct VisitorLoadVariant; -} // namespace core - template class BaseRecord; @@ -135,11 +126,11 @@ class RecordComponent : public BaseRecordComponent friend class MeshRecordComponent; template friend T &internal::makeOwning(T &self, Series); - friend class core::ConfigureLoadStore; - friend class core::ConfigureLoadStoreFromBuffer; - friend class core::ConfigureStoreChunkFromBuffer; - friend struct core::VisitorEnqueueLoadVariant; - friend struct core::VisitorLoadVariant; + friend class ConfigureLoadStore; + friend class ConfigureLoadStoreFromBuffer; + friend class ConfigureStoreChunkFromBuffer; + friend struct VisitorEnqueueLoadVariant; + friend struct VisitorLoadVariant; public: enum class Allocation diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp index 19cccc6789..db0c9cef2e 100644 --- a/include/openPMD/RecordComponent.tpp +++ b/include/openPMD/RecordComponent.tpp @@ -196,8 +196,7 @@ inline auto RecordComponent::visit(Args &&...args) // definitions for LoadStoreChunk.hpp template -auto core::ConfigureLoadStore::enqueueStore(F &&createBuffer) - -> DynamicMemoryView +auto ConfigureLoadStore::enqueueStore(F &&createBuffer) -> DynamicMemoryView { return m_rc.storeChunkSpanCreateBuffer_impl( storeChunkConfig(), std::forward(createBuffer)); diff --git a/include/openPMD/backend/Attributable.hpp b/include/openPMD/backend/Attributable.hpp index b133f28e07..8767e92cb0 100644 --- a/include/openPMD/backend/Attributable.hpp +++ b/include/openPMD/backend/Attributable.hpp @@ -213,11 +213,6 @@ namespace debug void printDirty(Series const &); } -namespace core -{ - class ConfigureLoadStore; -} - /** @brief Layer to manage storage of attributes associated with file objects. * * Mandatory and user-defined Attributes and their data for every object in the @@ -249,7 +244,7 @@ class Attributable friend class internal::AttributableData; friend class Snapshots; friend struct internal::HomogenizeExtents; - friend class core::ConfigureLoadStore; + friend class ConfigureLoadStore; protected: // tag for internal constructor diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index dd81ef4286..9fb5e4bb81 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -57,415 +57,389 @@ namespace } } // namespace -namespace core -{ - ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) : m_rc(rc) - {} +ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) : m_rc(rc) +{} - auto ConfigureLoadStore::dim() const -> uint8_t - { - return m_rc.getDimensionality(); - } +auto ConfigureLoadStore::dim() const -> uint8_t +{ + return m_rc.getDimensionality(); +} - auto ConfigureLoadStore::storeChunkConfig() -> internal::LoadStoreConfig - { - return internal::LoadStoreConfig{getOffset(), getExtent()}; - } +auto ConfigureLoadStore::storeChunkConfig() -> internal::LoadStoreConfig +{ + return internal::LoadStoreConfig{getOffset(), getExtent()}; +} - auto ConfigureLoadStore::deferFlush(Attributable &attr) - { - auto index = attr.IOHandler()->m_flushCounter; - return [attr, - old_index = *index, - current_index = std::weak_ptr(index)]() mutable { - auto lock_current_index = current_index.lock(); - if (!lock_current_index || *lock_current_index >= old_index) - { - return; - } - attr.seriesFlush(); - }; - } +auto ConfigureLoadStore::deferFlush(Attributable &attr) +{ + auto index = attr.IOHandler()->m_flushCounter; + return [attr, + old_index = *index, + current_index = std::weak_ptr(index)]() mutable { + auto lock_current_index = current_index.lock(); + if (!lock_current_index || *lock_current_index >= old_index) + { + return; + } + attr.seriesFlush(); + }; +} - auto ConfigureLoadStore::getOffset() -> Offset const & +auto ConfigureLoadStore::getOffset() -> Offset const & +{ + if (!m_offset.has_value()) { - if (!m_offset.has_value()) + if (m_rc.joinedDimension().has_value()) { - if (m_rc.joinedDimension().has_value()) - { - m_offset = std::make_optional(); - } - else - { - m_offset = std::make_optional(dim(), 0); - } + m_offset = std::make_optional(); + } + else + { + m_offset = std::make_optional(dim(), 0); } - return *m_offset; } + return *m_offset; +} - auto ConfigureLoadStore::getExtent() -> Extent const & +auto ConfigureLoadStore::getExtent() -> Extent const & +{ + if (!m_extent.has_value()) { - if (!m_extent.has_value()) + m_extent = std::make_optional(m_rc.getExtent()); + if (m_offset.has_value()) { - m_extent = std::make_optional(m_rc.getExtent()); - if (m_offset.has_value()) + auto it_o = m_offset->begin(); + auto end_o = m_offset->end(); + auto it_e = m_extent->begin(); + auto end_e = m_extent->end(); + for (; it_o != end_o && it_e != end_e; ++it_e, ++it_o) { - auto it_o = m_offset->begin(); - auto end_o = m_offset->end(); - auto it_e = m_extent->begin(); - auto end_e = m_extent->end(); - for (; it_o != end_o && it_e != end_e; ++it_e, ++it_o) - { - *it_e -= *it_o; - } + *it_e -= *it_o; } } - return *m_extent; } + return *m_extent; +} - auto ConfigureLoadStore::withSharedPtr_impl_mut( - std::shared_ptr data, Datatype datatype) - -> openPMD::ConfigureLoadStoreFromBuffer +auto ConfigureLoadStore::withSharedPtr_impl_mut( + std::shared_ptr data, Datatype datatype) + -> openPMD::ConfigureLoadStoreFromBuffer +{ + if (!data) { - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - return openPMD::ConfigureLoadStoreFromBuffer( - auxiliary::WriteBuffer(std::move(data)), - datatype, - {std::move(*this)}); + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); } - auto ConfigureLoadStore::withSharedPtr_impl_const( - std::shared_ptr data, Datatype datatype) - -> openPMD::ConfigureStoreChunkFromBuffer + return openPMD::ConfigureLoadStoreFromBuffer( + auxiliary::WriteBuffer(std::move(data)), datatype, {std::move(*this)}); +} +auto ConfigureLoadStore::withSharedPtr_impl_const( + std::shared_ptr data, Datatype datatype) + -> openPMD::ConfigureStoreChunkFromBuffer +{ + if (!data) { - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - return openPMD::ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer(std::move(data)), - datatype, - {std::move(*this)}); + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); } + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer(std::move(data)), datatype, {std::move(*this)}); +} - template - auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) - -> shared_ptr_return_type +template +auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) + -> shared_ptr_return_type +{ + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) { - using T_decayed = std::remove_cv_t>; - constexpr auto dtype = determineDatatype(); - if constexpr (std::is_const_v) - { - return withSharedPtr_impl_const(data, dtype); - } - else - { - return withSharedPtr_impl_mut(data, dtype); - } + return withSharedPtr_impl_const(data, dtype); } - - auto ConfigureLoadStore::withUniquePtr_impl_mut( - UniquePtrWithLambda data, Datatype dtype) - -> openPMD::ConfigureStoreChunkFromBuffer - + else { - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - - return openPMD::ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer(std::move(data)), dtype, {std::move(*this)}); + return withSharedPtr_impl_mut(data, dtype); } - auto ConfigureLoadStore::withUniquePtr_impl_const( - UniquePtrWithLambda data, Datatype dtype) - -> openPMD::ConfigureStoreChunkFromBuffer +} - { - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } +auto ConfigureLoadStore::withUniquePtr_impl_mut( + UniquePtrWithLambda data, Datatype dtype) + -> openPMD::ConfigureStoreChunkFromBuffer - void const *raw_ptr = data.release(); - auto &deleter = data.get_deleter(); - return openPMD::ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer( - std::shared_ptr( - raw_ptr, - [deleter_lambda = std::move(deleter)](auto const *p) { - deleter_lambda(p); - })), - dtype, - {std::move(*this)}); +{ + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); } - template - auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) - -> unique_ptr_return_type + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer(std::move(data)), dtype, {std::move(*this)}); +} +auto ConfigureLoadStore::withUniquePtr_impl_const( + UniquePtrWithLambda data, Datatype dtype) + -> openPMD::ConfigureStoreChunkFromBuffer + +{ + if (!data) { - using T_decayed = std::remove_cv_t>; - constexpr auto dtype = determineDatatype(); - if constexpr (std::is_const_v) - { - return withUniquePtr_impl_const( - std::move(data).template static_cast_(), dtype); - } - else - { - return withUniquePtr_impl_mut( - std::move(data).template static_cast_(), dtype); - } + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); } - auto ConfigureLoadStore::withRawPtr_impl_mut(void *data, Datatype dtype) - -> openPMD::ConfigureLoadStoreFromBuffer + void const *raw_ptr = data.release(); + auto &deleter = data.get_deleter(); + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer( + std::shared_ptr( + raw_ptr, + [deleter_lambda = std::move(deleter)](auto const *p) { + deleter_lambda(p); + })), + dtype, + {std::move(*this)}); +} +template +auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) + -> unique_ptr_return_type + +{ + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) { - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - return openPMD::ConfigureLoadStoreFromBuffer( - auxiliary::WriteBuffer(auxiliary::shareRaw(data)), - dtype, - {std::move(*this)}); + return withUniquePtr_impl_const( + std::move(data).template static_cast_(), dtype); } - - auto - ConfigureLoadStore::withRawPtr_impl_const(void const *data, Datatype dtype) - -> openPMD::ConfigureStoreChunkFromBuffer + else { - if (!data) - { - throw std::runtime_error( - "Unallocated pointer passed during chunk store."); - } - return openPMD::ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer(auxiliary::shareRaw(data)), - dtype, - {std::move(*this)}); + return withUniquePtr_impl_mut( + std::move(data).template static_cast_(), dtype); } +} - template - auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type +auto ConfigureLoadStore::withRawPtr_impl_mut(void *data, Datatype dtype) + -> openPMD::ConfigureLoadStoreFromBuffer +{ + if (!data) { - using T_decayed = std::remove_cv_t>; - constexpr auto dtype = determineDatatype(); - if constexpr (std::is_const_v) - { - return withRawPtr_impl_const(data, dtype); - } - else - { - return withRawPtr_impl_mut(data, dtype); - } + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); } - - template - auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView + return openPMD::ConfigureLoadStoreFromBuffer( + auxiliary::WriteBuffer(auxiliary::shareRaw(data)), + dtype, + {std::move(*this)}); +} + +auto ConfigureLoadStore::withRawPtr_impl_const(void const *data, Datatype dtype) + -> openPMD::ConfigureStoreChunkFromBuffer +{ + if (!data) { - return m_rc.storeChunkSpan_impl(storeChunkConfig()); + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); } - - template - auto ConfigureLoadStore::enqueueLoad() - -> auxiliary::DeferredComputation> + return openPMD::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer(auxiliary::shareRaw(data)), + dtype, + {std::move(*this)}); +} + +template +auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type +{ + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) { - auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); - return auxiliary::DeferredComputation>( - [res_lambda = std::move(res), dflush = deferFlush(m_rc)]() mutable { - dflush(); - return res_lambda; - }); + return withRawPtr_impl_const(data, dtype); } - - template - auto ConfigureLoadStore::load(EnqueuePolicy ep) -> std::shared_ptr + else { - auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); - switch (ep) - { - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - m_rc.seriesFlush(); - break; - } - return res; + return withRawPtr_impl_mut(data, dtype); } +} - struct VisitorEnqueueLoadVariant - { - template - static auto - call(RecordComponent &rc, internal::LoadStoreConfig cfg, F &&dflush) - -> auxiliary::DeferredComputation< - auxiliary::detail::shared_ptr_dataset_types> - { - auto res = rc.loadChunkAllocate_impl(std::move(cfg)); - return auxiliary::DeferredComputation< - auxiliary::detail::shared_ptr_dataset_types>( - [res_lambda = std::move(res), - dflush_lambda = std::forward(dflush)]() mutable - -> auxiliary::detail::shared_ptr_dataset_types { - dflush_lambda(); - return res_lambda; - }); - } - }; +template +auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView +{ + return m_rc.storeChunkSpan_impl(storeChunkConfig()); +} - auto ConfigureLoadStore::enqueueLoadVariant() +template +auto ConfigureLoadStore::enqueueLoad() + -> auxiliary::DeferredComputation> +{ + auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); + return auxiliary::DeferredComputation>( + [res_lambda = std::move(res), dflush = deferFlush(m_rc)]() mutable { + dflush(); + return res_lambda; + }); +} + +template +auto ConfigureLoadStore::load(EnqueuePolicy ep) -> std::shared_ptr +{ + auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); + switch (ep) + { + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + m_rc.seriesFlush(); + break; + } + return res; +} + +struct VisitorEnqueueLoadVariant +{ + template + static auto + call(RecordComponent &rc, internal::LoadStoreConfig cfg, F &&dflush) -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types> { - return m_rc.visit( - this->storeChunkConfig(), deferFlush(m_rc)); + auto res = rc.loadChunkAllocate_impl(std::move(cfg)); + return auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types>( + [res_lambda = std::move(res), + dflush_lambda = std::forward(dflush)]() mutable + -> auxiliary::detail::shared_ptr_dataset_types { + dflush_lambda(); + return res_lambda; + }); } +}; - struct VisitorLoadVariant - { - template - static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) - -> auxiliary::detail::shared_ptr_dataset_types - { - return rc.loadChunkAllocate_impl(std::move(cfg)); - } - }; +auto ConfigureLoadStore::enqueueLoadVariant() -> auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types> +{ + return m_rc.visit( + this->storeChunkConfig(), deferFlush(m_rc)); +} - auto ConfigureLoadStore::loadVariant(EnqueuePolicy ep) +struct VisitorLoadVariant +{ + template + static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) -> auxiliary::detail::shared_ptr_dataset_types { - auto res = m_rc.visit(this->storeChunkConfig()); - switch (ep) - { - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - m_rc.seriesFlush(); - break; - } - return res; + return rc.loadChunkAllocate_impl(std::move(cfg)); } +}; - ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( - auxiliary::WriteBuffer buffer, Datatype dt, ConfigureLoadStore &&core) - : ConfigureLoadStore(std::move(core)) - , m_buffer(std::move(buffer)) - , m_datatype(dt) - {} - - auto ConfigureStoreChunkFromBuffer::storeChunkConfig() - -> internal::LoadStoreConfigWithBuffer - { - return internal::LoadStoreConfigWithBuffer{ - this->getOffset(), this->getExtent(), m_mem_select}; +auto ConfigureLoadStore::loadVariant(EnqueuePolicy ep) + -> auxiliary::detail::shared_ptr_dataset_types +{ + auto res = m_rc.visit(this->storeChunkConfig()); + switch (ep) + { + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + m_rc.seriesFlush(); + break; } + return res; +} + +ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( + auxiliary::WriteBuffer buffer, Datatype dt, ConfigureLoadStore &&core) + : ConfigureLoadStore(std::move(core)) + , m_buffer(std::move(buffer)) + , m_datatype(dt) +{} - auto ConfigureStoreChunkFromBuffer::enqueueStore() - -> auxiliary::DeferredComputation - { - this->m_rc.storeChunk_impl( - std::move(m_buffer), m_datatype, storeChunkConfig()); - return auxiliary::DeferredComputation( - [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); - } +auto ConfigureStoreChunkFromBuffer::storeChunkConfig() + -> internal::LoadStoreConfigWithBuffer +{ + return internal::LoadStoreConfigWithBuffer{ + this->getOffset(), this->getExtent(), m_mem_select}; +} - auto ConfigureStoreChunkFromBuffer::store(EnqueuePolicy ep) -> void - { - this->m_rc.storeChunk_impl( - std::move(m_buffer), m_datatype, storeChunkConfig()); - switch (ep) - { - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - m_rc.seriesFlush(); - break; - } - } +auto ConfigureStoreChunkFromBuffer::enqueueStore() + -> auxiliary::DeferredComputation +{ + this->m_rc.storeChunk_impl( + std::move(m_buffer), m_datatype, storeChunkConfig()); + return auxiliary::DeferredComputation( + [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); +} - auto ConfigureLoadStoreFromBuffer::enqueueLoad() - -> auxiliary::DeferredComputation - { - auto *shared_ptr = std::get_if( - &this->m_buffer.as_variant()); - if (!shared_ptr) - { - throw std::runtime_error( - "ConfigureLoadStoreFromBuffer must be instantiated with a " - "non-const shared_ptr type."); - } - this->m_rc.loadChunk_impl( - *shared_ptr, m_datatype, this->storeChunkConfig()); - return auxiliary::DeferredComputation( - [dflush = this->deferFlush(this->m_rc)]() mutable -> void { - dflush(); - }); +auto ConfigureStoreChunkFromBuffer::store(EnqueuePolicy ep) -> void +{ + this->m_rc.storeChunk_impl( + std::move(m_buffer), m_datatype, storeChunkConfig()); + switch (ep) + { + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + m_rc.seriesFlush(); + break; } +} - auto ConfigureLoadStoreFromBuffer::load(EnqueuePolicy ep) -> void +auto ConfigureLoadStoreFromBuffer::enqueueLoad() + -> auxiliary::DeferredComputation +{ + auto *shared_ptr = std::get_if( + &this->m_buffer.as_variant()); + if (!shared_ptr) { - auto *shared_ptr = std::get_if( - &this->m_buffer.as_variant()); - if (!shared_ptr) - { - throw std::runtime_error( - "ConfigureLoadStoreFromBuffer must be instantiated with a " - "non-const shared_ptr type."); - } - this->m_rc.loadChunk_impl( - *shared_ptr, m_datatype, this->storeChunkConfig()); - switch (ep) - { - - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - this->m_rc.seriesFlush(); - break; - } + throw std::runtime_error( + "ConfigureLoadStoreFromBuffer must be instantiated with a " + "non-const shared_ptr type."); } -} // namespace core - -namespace compose + this->m_rc.loadChunk_impl( + *shared_ptr, m_datatype, this->storeChunkConfig()); + return auxiliary::DeferredComputation( + [dflush = this->deferFlush(this->m_rc)]() mutable -> void { + dflush(); + }); +} + +auto ConfigureLoadStoreFromBuffer::load(EnqueuePolicy ep) -> void { - template - auto ConfigureLoadStore::extent(Extent extent) -> ChildClass & + auto *shared_ptr = std::get_if( + &this->m_buffer.as_variant()); + if (!shared_ptr) { - static_cast(this)->m_extent = - std::make_optional(std::move(extent)); - return *static_cast(this); + throw std::runtime_error( + "ConfigureLoadStoreFromBuffer must be instantiated with a " + "non-const shared_ptr type."); } - - template - auto ConfigureLoadStore::offset(Offset offset) -> ChildClass & + this->m_rc.loadChunk_impl( + *shared_ptr, m_datatype, this->storeChunkConfig()); + switch (ep) { - static_cast(this)->m_offset = - std::make_optional(std::move(offset)); - return *static_cast(this); - } - template - auto ConfigureStoreChunkFromBuffer::memorySelection( - MemorySelection sel) -> ChildClass & - { - static_cast(this)->m_mem_select = - std::make_optional(std::move(sel)); - return *static_cast(this); + case EnqueuePolicy::Defer: + break; + case EnqueuePolicy::Immediate: + this->m_rc.seriesFlush(); + break; } -} // namespace compose +} -template class compose::ConfigureLoadStore; -template class compose::ConfigureLoadStore; -template class compose::ConfigureStoreChunkFromBuffer< - ConfigureLoadStoreFromBuffer>; +void ConfigureLoadStore::extent_impl(Extent extent) +{ + m_extent = std::make_optional(std::move(extent)); +} + +void ConfigureLoadStore::offset_impl(Offset offset) +{ + m_offset = std::make_optional(std::move(offset)); +} + +void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) +{ + m_mem_select = std::make_optional(std::move(sel)); +} +// namespace core // need this for clang-tidy #define OPENPMD_ARRAY(type) type[] @@ -473,15 +447,15 @@ template class compose::ConfigureStoreChunkFromBuffer< #define OPENPMD_APPLY_TEMPLATE(template_, type) template_ #define INSTANTIATE_METHOD_TEMPLATES(dtype) \ - template auto core::ConfigureLoadStore::enqueueLoad() \ + template auto ConfigureLoadStore::enqueueLoad() \ -> auxiliary::DeferredComputation; \ - template auto core::ConfigureLoadStore::load(EnqueuePolicy) \ + template auto ConfigureLoadStore::load(EnqueuePolicy) \ ->std::shared_ptr; #define INSTANTIATE_FULLMATRIX(dtype) \ - template auto core::ConfigureLoadStore::withSharedPtr( \ + template auto ConfigureLoadStore::withSharedPtr( \ std::shared_ptr data) -> shared_ptr_return_type; \ - template auto core::ConfigureLoadStore::withUniquePtr( \ + template auto ConfigureLoadStore::withUniquePtr( \ UniquePtrWithLambda data) -> unique_ptr_return_type; #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ @@ -490,13 +464,12 @@ template class compose::ConfigureStoreChunkFromBuffer< INSTANTIATE_FULLMATRIX(type const) \ INSTANTIATE_FULLMATRIX(OPENPMD_ARRAY(type)) \ INSTANTIATE_FULLMATRIX(OPENPMD_ARRAY(type const)) \ - template auto core::ConfigureLoadStore::enqueueStore() \ + template auto ConfigureLoadStore::enqueueStore() \ -> DynamicMemoryView; \ - template auto core::ConfigureLoadStore::withRawPtr(OPENPMD_POINTER(type) \ - data) \ + template auto ConfigureLoadStore::withRawPtr(OPENPMD_POINTER(type) data) \ ->OPENPMD_APPLY_TEMPLATE(shared_ptr_return_type, type); \ - template auto core::ConfigureLoadStore::withRawPtr( \ - OPENPMD_POINTER(type const) data) \ + template auto ConfigureLoadStore::withRawPtr(OPENPMD_POINTER(type const) \ + data) \ ->OPENPMD_APPLY_TEMPLATE(shared_ptr_return_type, type const); OPENPMD_FOREACH_DATASET_DATATYPE( @@ -509,11 +482,4 @@ OPENPMD_FOREACH_DATASET_DATATYPE( #undef OPENPMD_ARRAY #undef OPENPMD_POINTER #undef OPENPMD_APPLY_TEMPLATE - -ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) - : core::ConfigureLoadStore{rc} -{} -ConfigureLoadStore::ConfigureLoadStore(core::ConfigureLoadStore &&core) - : core::ConfigureLoadStore{std::move(core)} -{} } // namespace openPMD From ddcfc4d4a30a9d76f109c87a9c04d007891b32e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 12 Feb 2026 14:55:24 +0100 Subject: [PATCH 27/47] Move wrappers to header code --- include/openPMD/LoadStoreChunk.tpp | 51 +++++++++++++++++++++++ src/LoadStoreChunk.cpp | 66 +----------------------------- 2 files changed, 52 insertions(+), 65 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp index db24185932..f6b0fedf15 100644 --- a/include/openPMD/LoadStoreChunk.tpp +++ b/include/openPMD/LoadStoreChunk.tpp @@ -4,12 +4,63 @@ namespace openPMD { +template +auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) + -> shared_ptr_return_type +{ + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) + { + return withSharedPtr_impl_const(data, dtype); + } + else + { + return withSharedPtr_impl_mut(data, dtype); + } +} + +template +auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) + -> unique_ptr_return_type + +{ + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) + { + return withUniquePtr_impl_const( + std::move(data).template static_cast_(), dtype); + } + else + { + return withUniquePtr_impl_mut( + std::move(data).template static_cast_(), dtype); + } +} + template auto ConfigureLoadStore::withUniquePtr(std::unique_ptr data) -> unique_ptr_return_type { return withUniquePtr(UniquePtrWithLambda(std::move(data))); } + +template +auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type +{ + using T_decayed = std::remove_cv_t>; + constexpr auto dtype = determineDatatype(); + if constexpr (std::is_const_v) + { + return withRawPtr_impl_const(data, dtype); + } + else + { + return withRawPtr_impl_mut(data, dtype); + } +} + template auto ConfigureLoadStore::withContiguousContainer(T_ContiguousContainer &data) -> std::enable_if_t< diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 9fb5e4bb81..980607be20 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -146,22 +146,6 @@ auto ConfigureLoadStore::withSharedPtr_impl_const( auxiliary::WriteBuffer(std::move(data)), datatype, {std::move(*this)}); } -template -auto ConfigureLoadStore::withSharedPtr(std::shared_ptr data) - -> shared_ptr_return_type -{ - using T_decayed = std::remove_cv_t>; - constexpr auto dtype = determineDatatype(); - if constexpr (std::is_const_v) - { - return withSharedPtr_impl_const(data, dtype); - } - else - { - return withSharedPtr_impl_mut(data, dtype); - } -} - auto ConfigureLoadStore::withUniquePtr_impl_mut( UniquePtrWithLambda data, Datatype dtype) -> openPMD::ConfigureStoreChunkFromBuffer @@ -199,24 +183,6 @@ auto ConfigureLoadStore::withUniquePtr_impl_const( dtype, {std::move(*this)}); } -template -auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda data) - -> unique_ptr_return_type - -{ - using T_decayed = std::remove_cv_t>; - constexpr auto dtype = determineDatatype(); - if constexpr (std::is_const_v) - { - return withUniquePtr_impl_const( - std::move(data).template static_cast_(), dtype); - } - else - { - return withUniquePtr_impl_mut( - std::move(data).template static_cast_(), dtype); - } -} auto ConfigureLoadStore::withRawPtr_impl_mut(void *data, Datatype dtype) -> openPMD::ConfigureLoadStoreFromBuffer @@ -246,21 +212,6 @@ auto ConfigureLoadStore::withRawPtr_impl_const(void const *data, Datatype dtype) {std::move(*this)}); } -template -auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type -{ - using T_decayed = std::remove_cv_t>; - constexpr auto dtype = determineDatatype(); - if constexpr (std::is_const_v) - { - return withRawPtr_impl_const(data, dtype); - } - else - { - return withRawPtr_impl_mut(data, dtype); - } -} - template auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView { @@ -452,25 +403,10 @@ void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) std::shared_ptr, dtype)>; \ template auto ConfigureLoadStore::load(EnqueuePolicy) \ ->std::shared_ptr; -#define INSTANTIATE_FULLMATRIX(dtype) \ - template auto ConfigureLoadStore::withSharedPtr( \ - std::shared_ptr data) -> shared_ptr_return_type; \ - template auto ConfigureLoadStore::withUniquePtr( \ - UniquePtrWithLambda data) -> unique_ptr_return_type; #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type)) \ - INSTANTIATE_FULLMATRIX(type) \ - INSTANTIATE_FULLMATRIX(type const) \ - INSTANTIATE_FULLMATRIX(OPENPMD_ARRAY(type)) \ - INSTANTIATE_FULLMATRIX(OPENPMD_ARRAY(type const)) \ - template auto ConfigureLoadStore::enqueueStore() \ - -> DynamicMemoryView; \ - template auto ConfigureLoadStore::withRawPtr(OPENPMD_POINTER(type) data) \ - ->OPENPMD_APPLY_TEMPLATE(shared_ptr_return_type, type); \ - template auto ConfigureLoadStore::withRawPtr(OPENPMD_POINTER(type const) \ - data) \ - ->OPENPMD_APPLY_TEMPLATE(shared_ptr_return_type, type const); + template auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView; OPENPMD_FOREACH_DATASET_DATATYPE( INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) From 238fcb6d779e9b22a97b14edf2dfb76b4a8da6dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Fri, 13 Feb 2026 14:08:40 +0100 Subject: [PATCH 28/47] Interface cleanup --- include/openPMD/LoadStoreChunk.hpp | 64 ++++++++++++++---------------- src/LoadStoreChunk.cpp | 2 - 2 files changed, 30 insertions(+), 36 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 53a10544c3..8111e628f7 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -45,7 +45,7 @@ namespace auxiliary::detail #undef OPENPMD_ENUMERATE_TYPES } // namespace auxiliary::detail -enum class EnqueuePolicy +enum class EnqueuePolicy : std::uint8_t { Defer, Immediate @@ -73,12 +73,16 @@ class ConfigureLoadStore auto deferFlush(Attributable &); + auto getOffset() -> Offset const &; + auto getExtent() -> Extent const &; + // The below methods return void. // For chaining calls, they should return *this, but this class right // here is going to be somewhere in the inheritance chain, and the final // class should be returned. Could be solved more elegantly with CRT, // but that blows up compile-time, so we make internal void functions // and then repeat them in the final classes. + // (e.g. ConfigureLoadStoreFromBuffer::offset()) void offset_impl(Offset); void extent_impl(Extent); @@ -100,9 +104,7 @@ class ConfigureLoadStore public: using this_t = ConfigureLoadStore; - auto getOffset() -> Offset const &; - auto getExtent() -> Extent const &; - + // Configuration methods (always available) auto offset(Offset offset) -> this_t & { offset_impl(std::move(offset)); @@ -113,43 +115,29 @@ class ConfigureLoadStore extent_impl(std::move(extent)); return *this; } + /* * If the type is non-const, then the return type should be - * ConfigureLoadStoreFromBuffer<>, ... + * ConfigureLoadStoreFromBuffer, but if it is a const type, Load operations + * make no sense, so the return type should be + * ConfigureStoreChunkFromBuffer<>. */ template - struct shared_ptr_return_type_impl - { - using return_type = openPMD::ConfigureLoadStoreFromBuffer; - using normalize_pointer_type = std::shared_ptr>; - }; - /* - * ..., but if it is a const type, Load operations make no sense, so the - * return type should be ConfigureStoreChunkFromBuffer<>. - */ - template - struct shared_ptr_return_type_impl - { - using return_type = openPMD::ConfigureStoreChunkFromBuffer; - using normalize_pointer_type = - std::shared_ptr const>; - }; - - template - using shared_ptr_return_type = typename shared_ptr_return_type_impl< - std::remove_extent_t>::return_type; - template - using shared_ptr_normalized_type = typename shared_ptr_return_type_impl< - std::remove_extent_t>::normalized_pointer_type; + using shared_ptr_return_type = std::conditional_t< + std::is_const_v, + ConfigureStoreChunkFromBuffer, + ConfigureLoadStoreFromBuffer>; /* * As loading into unique pointer types makes no sense, the case is * simpler for unique pointers. Just remove the array extents here. + * (Our interface wrappers still support const-type unique pointers, + * but the internal logic does not handle them separately.) */ template using unique_ptr_return_type = openPMD::ConfigureStoreChunkFromBuffer; - // @todo rvalue references..? + // Buffer specification methods (return specialized configurations) template auto withSharedPtr(std::shared_ptr) -> shared_ptr_return_type; template @@ -164,6 +152,7 @@ class ConfigureLoadStore auxiliary::IsContiguousContainer_v, shared_ptr_return_type>; + // Enqueue methods (deferred execution) template [[nodiscard]] auto enqueueStore() -> DynamicMemoryView; // definition for this one is in RecordComponent.tpp since it needs the @@ -175,12 +164,13 @@ class ConfigureLoadStore [[nodiscard]] auto enqueueLoad() -> auxiliary::DeferredComputation>; - template - [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr; - [[nodiscard]] auto enqueueLoadVariant() -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types>; + // Direct execution methods (with EnqueuePolicy) + template + [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr; + [[nodiscard]] auto loadVariant(EnqueuePolicy) -> auxiliary::detail::shared_ptr_dataset_types; }; @@ -205,9 +195,12 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore // and then repeat them in the final classes. void memorySelection_impl(MemorySelection); + auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; + public: using this_t = ConfigureStoreChunkFromBuffer; + // Configuration methods (always available) auto offset(Offset offset) -> this_t & { offset_impl(std::move(offset)); @@ -224,10 +217,10 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore return *this; } - auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; - + // Enqueue method (deferred execution) auto enqueueStore() -> auxiliary::DeferredComputation; + // Direct execution method (with EnqueuePolicy) auto store(EnqueuePolicy) -> void; /** This intentionally shadows the parent class's enqueueLoad methods in @@ -263,6 +256,7 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer public: using this_t = ConfigureLoadStoreFromBuffer; + // Configuration methods (always available) auto offset(Offset offset) -> this_t & { offset_impl(std::move(offset)); @@ -279,8 +273,10 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer return *this; } + // Enqueue method (deferred execution) auto enqueueLoad() -> auxiliary::DeferredComputation; + // Direct execution method (with EnqueuePolicy) auto load(EnqueuePolicy) -> void; }; diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 980607be20..7cf87a105e 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -7,14 +7,12 @@ #include "openPMD/auxiliary/Memory.hpp" #include "openPMD/auxiliary/Memory_internal.hpp" #include "openPMD/auxiliary/ShareRawInternal.hpp" -#include "openPMD/auxiliary/TypeTraits.hpp" #include "openPMD/auxiliary/UniquePtr.hpp" // comment to keep clang-format from reordering #include "openPMD/DatatypeMacros.hpp" #include "openPMD/backend/Attributable.hpp" -#include #include #include #include From 640c89bd8eb30a9e55dc2eb47218c7aa972ff71f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Thu, 12 Mar 2026 14:58:07 +0100 Subject: [PATCH 29/47] Fix after rebase --- include/openPMD/Datatype.tpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/include/openPMD/Datatype.tpp b/include/openPMD/Datatype.tpp index 0c8fcbdb47..c42f1de02b 100644 --- a/include/openPMD/Datatype.tpp +++ b/include/openPMD/Datatype.tpp @@ -301,11 +301,6 @@ constexpr inline bool isSigned(Datatype d) return switchType(d); } -constexpr inline bool isSameChar(Datatype d, Datatype e) -{ - return isChar(d) && isChar(e) && isSigned(d) == isSigned(e); -} - constexpr bool isSame(openPMD::Datatype const d, openPMD::Datatype const e) { return From 1170f0c023793c4802a7a30454ca307f49a577c8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 12 Mar 2026 14:06:55 +0000 Subject: [PATCH 30/47] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- include/openPMD/Datatype.tpp | 2 +- src/RecordComponent.cpp | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/include/openPMD/Datatype.tpp b/include/openPMD/Datatype.tpp index c42f1de02b..b09351fd77 100644 --- a/include/openPMD/Datatype.tpp +++ b/include/openPMD/Datatype.tpp @@ -230,7 +230,7 @@ namespace detail { return is_char_v; } - template + template static constexpr bool call() { return false; diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index b92db90c0b..e5ea522760 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -922,14 +922,14 @@ void RecordComponent::loadChunk_impl( * Attention: Do NOT use operator==(), doesnt work properly on Windows! */ if (!isSame(dtype_requested, getDatatype()) && !constant()) - { - std::string const data_type_str = datatypeToString(getDatatype()); - std::string const requ_type_str = datatypeToString(dtype_requested); - std::string err_msg = - "Type conversion during chunk loading not yet implemented! "; - err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; - throw std::runtime_error(err_msg); - } + { + std::string const data_type_str = datatypeToString(getDatatype()); + std::string const requ_type_str = datatypeToString(dtype_requested); + std::string err_msg = + "Type conversion during chunk loading not yet implemented! "; + err_msg += "Data: " + data_type_str + "; Load as: " + requ_type_str; + throw std::runtime_error(err_msg); + } auto dim = getDimensionality(); auto [offset, extent, memorySelection] = std::move(cfg); From 287371d1a55a36fc51f2098a25d314edd024151c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 18:13:36 +0200 Subject: [PATCH 31/47] Suffix ..Raw for internal legacy store/load operations --- include/openPMD/LoadStoreChunk.hpp | 19 ++++++++++++------- include/openPMD/RecordComponent.tpp | 4 ++-- include/openPMD/auxiliary/Future.hpp | 1 + src/LoadStoreChunk.cpp | 10 +++++----- src/RecordComponent.cpp | 14 +++++++------- src/auxiliary/Future.cpp | 6 ++++++ 6 files changed, 33 insertions(+), 21 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 8111e628f7..38504c662d 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -167,17 +167,19 @@ class ConfigureLoadStore [[nodiscard]] auto enqueueLoadVariant() -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types>; +private: // Direct execution methods (with EnqueuePolicy) template - [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr; + [[nodiscard]] auto loadRaw(EnqueuePolicy) -> std::shared_ptr; - [[nodiscard]] auto loadVariant(EnqueuePolicy) + [[nodiscard]] auto loadVariantRaw(EnqueuePolicy) -> auxiliary::detail::shared_ptr_dataset_types; }; class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore { friend class ConfigureLoadStore; + friend class RecordComponent; protected: auxiliary::WriteBuffer m_buffer; @@ -220,9 +222,6 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore // Enqueue method (deferred execution) auto enqueueStore() -> auxiliary::DeferredComputation; - // Direct execution method (with EnqueuePolicy) - auto store(EnqueuePolicy) -> void; - /** This intentionally shadows the parent class's enqueueLoad methods in * order to show a compile error when using load() on an object * of this class. The parent method can still be accessed through @@ -237,8 +236,12 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore "unique_ptr."); } +private: + // Direct execution method (with EnqueuePolicy) + auto storeRaw(EnqueuePolicy) -> void; + template - auto load(EnqueuePolicy) + auto loadRaw(EnqueuePolicy) { static_assert( auxiliary::dependent_false_v, @@ -250,6 +253,7 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer { friend class ConfigureLoadStore; + friend class RecordComponent; using ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; @@ -276,8 +280,9 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer // Enqueue method (deferred execution) auto enqueueLoad() -> auxiliary::DeferredComputation; +private: // Direct execution method (with EnqueuePolicy) - auto load(EnqueuePolicy) -> void; + auto loadRaw(EnqueuePolicy) -> void; }; } // namespace openPMD diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp index db0c9cef2e..3c87d6d0f0 100644 --- a/include/openPMD/RecordComponent.tpp +++ b/include/openPMD/RecordComponent.tpp @@ -47,7 +47,7 @@ RecordComponent::storeChunk(std::unique_ptr data, Offset o, Extent e) .offset(std::move(o)) .extent(std::move(e)) .withUniquePtr(std::move(data)) - .store(EnqueuePolicy::Defer); + .storeRaw(EnqueuePolicy::Defer); } template @@ -69,7 +69,7 @@ RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e) std::move(storeChunkConfig) .withContiguousContainer(data) - .store(EnqueuePolicy::Defer); + .storeRaw(EnqueuePolicy::Defer); } template diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index 8a4b2a516c..efb719ffd7 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -18,6 +18,7 @@ class DeferredComputation ~DeferredComputation(); auto get() -> T; + auto operator()() -> T; [[nodiscard]] auto valid() const noexcept -> bool; }; diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 7cf87a105e..e115415e13 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -229,7 +229,7 @@ auto ConfigureLoadStore::enqueueLoad() } template -auto ConfigureLoadStore::load(EnqueuePolicy ep) -> std::shared_ptr +auto ConfigureLoadStore::loadRaw(EnqueuePolicy ep) -> std::shared_ptr { auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); switch (ep) @@ -280,7 +280,7 @@ struct VisitorLoadVariant } }; -auto ConfigureLoadStore::loadVariant(EnqueuePolicy ep) +auto ConfigureLoadStore::loadVariantRaw(EnqueuePolicy ep) -> auxiliary::detail::shared_ptr_dataset_types { auto res = m_rc.visit(this->storeChunkConfig()); @@ -318,7 +318,7 @@ auto ConfigureStoreChunkFromBuffer::enqueueStore() [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); } -auto ConfigureStoreChunkFromBuffer::store(EnqueuePolicy ep) -> void +auto ConfigureStoreChunkFromBuffer::storeRaw(EnqueuePolicy ep) -> void { this->m_rc.storeChunk_impl( std::move(m_buffer), m_datatype, storeChunkConfig()); @@ -351,7 +351,7 @@ auto ConfigureLoadStoreFromBuffer::enqueueLoad() }); } -auto ConfigureLoadStoreFromBuffer::load(EnqueuePolicy ep) -> void +auto ConfigureLoadStoreFromBuffer::loadRaw(EnqueuePolicy ep) -> void { auto *shared_ptr = std::get_if( &this->m_buffer.as_variant()); @@ -399,7 +399,7 @@ void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) template auto ConfigureLoadStore::enqueueLoad() \ -> auxiliary::DeferredComputation; \ - template auto ConfigureLoadStore::load(EnqueuePolicy) \ + template auto ConfigureLoadStore::loadRaw(EnqueuePolicy) \ ->std::shared_ptr; #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index e5ea522760..38a9a6b75c 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -254,7 +254,7 @@ std::shared_ptr RecordComponent::loadChunkAllocate_impl( .offset(std::move(o)) .extent(std::move(e)) .withSharedPtr_impl_mut(newData, dtype) - .load(EnqueuePolicy::Defer); + .loadRaw(EnqueuePolicy::Defer); return newData; } @@ -852,7 +852,7 @@ std::shared_ptr RecordComponent::loadChunk(Offset o, Extent e) operation.extent(std::move(e)); } - return operation.load(EnqueuePolicy::Defer); + return operation.loadRaw(EnqueuePolicy::Defer); } namespace detail @@ -993,7 +993,7 @@ void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) operation.extent(std::move(e)); } - operation.withSharedPtr(std::move(data)).load(EnqueuePolicy::Defer); + operation.withSharedPtr(std::move(data)).loadRaw(EnqueuePolicy::Defer); } template @@ -1003,7 +1003,7 @@ void RecordComponent::loadChunkRaw(T *ptr, Offset offset, Extent extent) .offset(std::move(offset)) .extent(std::move(extent)) .withRawPtr(ptr) - .load(EnqueuePolicy::Defer); + .loadRaw(EnqueuePolicy::Defer); } template @@ -1013,7 +1013,7 @@ void RecordComponent::storeChunk(std::shared_ptr data, Offset o, Extent e) .offset(std::move(o)) .extent(std::move(e)) .withSharedPtr(std::move(data)) - .store(EnqueuePolicy::Defer); + .storeRaw(EnqueuePolicy::Defer); } template @@ -1024,7 +1024,7 @@ void RecordComponent::storeChunk( .offset(std::move(o)) .extent(std::move(e)) .withUniquePtr(std::move(data)) - .store(EnqueuePolicy::Defer); + .storeRaw(EnqueuePolicy::Defer); } template @@ -1034,7 +1034,7 @@ void RecordComponent::storeChunkRaw(T const *ptr, Offset offset, Extent extent) .offset(std::move(offset)) .extent(std::move(extent)) .withRawPtr(ptr) - .store(EnqueuePolicy::Defer); + .storeRaw(EnqueuePolicy::Defer); } template diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 6e91fb7119..6e3c540d6b 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -55,6 +55,12 @@ auto DeferredComputation::get() -> T return m_task(); } +template +auto DeferredComputation::operator()() -> T +{ + return m_task(); +} + template auto DeferredComputation::valid() const noexcept -> bool { From 561ebd3d1c25254d42016a07ee86a36ceddabd42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 18:18:09 +0200 Subject: [PATCH 32/47] Remove enqueue prefixes, these are now default --- include/openPMD/LoadStoreChunk.hpp | 14 +++++++------- include/openPMD/RecordComponent.tpp | 4 ++-- src/LoadStoreChunk.cpp | 14 +++++++------- src/RecordComponent.cpp | 2 +- test/ParallelIOTest.cpp | 13 ++++++------- test/SerialIOTest.cpp | 4 ++-- 6 files changed, 25 insertions(+), 26 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 38504c662d..0e7ba3e6ae 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -154,17 +154,17 @@ class ConfigureLoadStore // Enqueue methods (deferred execution) template - [[nodiscard]] auto enqueueStore() -> DynamicMemoryView; + [[nodiscard]] auto storeSpan() -> DynamicMemoryView; // definition for this one is in RecordComponent.tpp since it needs the // definition of class RecordComponent. template - [[nodiscard]] auto enqueueStore(F &&createBuffer) -> DynamicMemoryView; + [[nodiscard]] auto storeSpan(F &&createBuffer) -> DynamicMemoryView; template - [[nodiscard]] auto enqueueLoad() + [[nodiscard]] auto load() -> auxiliary::DeferredComputation>; - [[nodiscard]] auto enqueueLoadVariant() -> auxiliary::DeferredComputation< + [[nodiscard]] auto loadVariant() -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types>; private: @@ -220,7 +220,7 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore } // Enqueue method (deferred execution) - auto enqueueStore() -> auxiliary::DeferredComputation; + auto store() -> auxiliary::DeferredComputation; /** This intentionally shadows the parent class's enqueueLoad methods in * order to show a compile error when using load() on an object @@ -228,7 +228,7 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore * typecasting if needed. */ template - auto enqueueLoad() + auto load() { static_assert( auxiliary::dependent_false_v, @@ -278,7 +278,7 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer } // Enqueue method (deferred execution) - auto enqueueLoad() -> auxiliary::DeferredComputation; + auto load() -> auxiliary::DeferredComputation; private: // Direct execution method (with EnqueuePolicy) diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp index 3c87d6d0f0..cf6224c68c 100644 --- a/include/openPMD/RecordComponent.tpp +++ b/include/openPMD/RecordComponent.tpp @@ -79,7 +79,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer) return prepareLoadStore() .offset(std::move(o)) .extent(std::move(e)) - .enqueueStore(std::forward(createBuffer)); + .storeSpan(std::forward(createBuffer)); } template @@ -196,7 +196,7 @@ inline auto RecordComponent::visit(Args &&...args) // definitions for LoadStoreChunk.hpp template -auto ConfigureLoadStore::enqueueStore(F &&createBuffer) -> DynamicMemoryView +auto ConfigureLoadStore::storeSpan(F &&createBuffer) -> DynamicMemoryView { return m_rc.storeChunkSpanCreateBuffer_impl( storeChunkConfig(), std::forward(createBuffer)); diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index e115415e13..161a6b0455 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -211,13 +211,13 @@ auto ConfigureLoadStore::withRawPtr_impl_const(void const *data, Datatype dtype) } template -auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView +auto ConfigureLoadStore::storeSpan() -> DynamicMemoryView { return m_rc.storeChunkSpan_impl(storeChunkConfig()); } template -auto ConfigureLoadStore::enqueueLoad() +auto ConfigureLoadStore::load() -> auxiliary::DeferredComputation> { auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); @@ -263,7 +263,7 @@ struct VisitorEnqueueLoadVariant } }; -auto ConfigureLoadStore::enqueueLoadVariant() -> auxiliary::DeferredComputation< +auto ConfigureLoadStore::loadVariant() -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types> { return m_rc.visit( @@ -309,7 +309,7 @@ auto ConfigureStoreChunkFromBuffer::storeChunkConfig() this->getOffset(), this->getExtent(), m_mem_select}; } -auto ConfigureStoreChunkFromBuffer::enqueueStore() +auto ConfigureStoreChunkFromBuffer::store() -> auxiliary::DeferredComputation { this->m_rc.storeChunk_impl( @@ -332,7 +332,7 @@ auto ConfigureStoreChunkFromBuffer::storeRaw(EnqueuePolicy ep) -> void } } -auto ConfigureLoadStoreFromBuffer::enqueueLoad() +auto ConfigureLoadStoreFromBuffer::load() -> auxiliary::DeferredComputation { auto *shared_ptr = std::get_if( @@ -396,7 +396,7 @@ void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) #define OPENPMD_APPLY_TEMPLATE(template_, type) template_ #define INSTANTIATE_METHOD_TEMPLATES(dtype) \ - template auto ConfigureLoadStore::enqueueLoad() \ + template auto ConfigureLoadStore::load() \ -> auxiliary::DeferredComputation; \ template auto ConfigureLoadStore::loadRaw(EnqueuePolicy) \ @@ -404,7 +404,7 @@ void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type)) \ - template auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView; + template auto ConfigureLoadStore::storeSpan() -> DynamicMemoryView; OPENPMD_FOREACH_DATASET_DATATYPE( INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index 38a9a6b75c..81578d6d18 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -1043,7 +1043,7 @@ DynamicMemoryView RecordComponent::storeChunk(Offset offset, Extent extent) return prepareLoadStore() .offset(std::move(offset)) .extent(std::move(extent)) - .enqueueStore(); + .storeSpan(); } template diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp index e61d5c2d14..c72b9b1574 100644 --- a/test/ParallelIOTest.cpp +++ b/test/ParallelIOTest.cpp @@ -473,13 +473,13 @@ void available_chunks_test(std::string const &file_ending) .withContiguousContainer(ydata_firstandlastrow) .offset({0, 3ul * mpi_rank}) .extent({1, 3}) - .enqueueStore(); + .store(); E_y.prepareLoadStore() .offset({1, 3ul * mpi_rank}) .extent({3, 3}) .withContiguousContainer(ydata) .memorySelection({{1, 1}, {5, 5}}) - .enqueueStore(); + .store(); // if condition checks if this PR is available in ADIOS2: // https://github.com/ornladios/ADIOS2/pull/4169 if constexpr (CanTheMemorySelectionBeReset) @@ -488,7 +488,7 @@ void available_chunks_test(std::string const &file_ending) .withContiguousContainer(ydata_firstandlastrow) .offset({4, 3ul * mpi_rank}) .extent({1, 3}) - .enqueueStore(); + .store(); } it0.close(); } @@ -529,14 +529,13 @@ void available_chunks_test(std::string const &file_ending) auto E_y = it0.meshes["E"]["y"]; auto width = E_y.getExtent()[1]; auto first_row = - E_y.prepareLoadStore().extent({1, width}).enqueueLoad().get(); + E_y.prepareLoadStore().extent({1, width}).load().get(); auto middle_rows = E_y.prepareLoadStore() .offset({1, 0}) .extent({3, width}) - .enqueueLoad() + .load() .get(); - auto last_row = - E_y.prepareLoadStore().offset({4, 0}).enqueueLoad().get(); + auto last_row = E_y.prepareLoadStore().offset({4, 0}).load().get(); read.flush(); for (auto row : [&]() -> std::vector *> { diff --git a/test/SerialIOTest.cpp b/test/SerialIOTest.cpp index 42cb5b2087..ae6297ad5f 100644 --- a/test/SerialIOTest.cpp +++ b/test/SerialIOTest.cpp @@ -946,7 +946,7 @@ inline void constant_scalar(std::string const &file_ending) E_y.prepareLoadStore() .extent({1, 2, 3}) .withUniquePtr(std::move(E).static_cast_()) - .enqueueStore(); + .store(); // store a number of predefined attributes in E Mesh &E_mesh = s.snapshots()[1].meshes["E"]; @@ -1757,7 +1757,7 @@ inline void write_test( auto opaqueTypeDataset = rc.visit(); auto variantTypeDataset = rc.loadChunkVariant(); - auto variantTypeDataset2 = rc.prepareLoadStore().enqueueLoadVariant().get(); + auto variantTypeDataset2 = rc.prepareLoadStore().loadVariant().get(); rc.seriesFlush(); for (auto ptr : {&variantTypeDataset, &variantTypeDataset2}) { From a5c708fcba493f6e81643f3061d4bb727b91bdac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 18:48:39 +0200 Subject: [PATCH 33/47] Add future task with caching option for when no computation is needed --- include/openPMD/auxiliary/Future.hpp | 39 ++++++++-- src/auxiliary/Future.cpp | 104 +++++++++++++++++++-------- 2 files changed, 110 insertions(+), 33 deletions(-) diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index efb719ffd7..15186a85df 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -1,8 +1,31 @@ #pragma once -#include "openPMD/auxiliary/TypeTraits.hpp" - #include +#include + +namespace openPMD::auxiliary::detail +{ +template +struct OneTimeTask +{ + using task_type = std::function; + task_type m_task; + bool m_task_valid = true; + + auto operator()() -> T; +}; + +template +struct CachedValue +{ + T val; +}; +template <> +struct CachedValue +{ + // this is silly +}; +} // namespace openPMD::auxiliary::detail namespace openPMD::auxiliary { @@ -10,16 +33,24 @@ template class DeferredComputation { using task_type = std::function; - task_type m_task; - bool m_valid = false; + using cached_type = std::conditional_t< + std::is_void_v, + // just something that is not void + detail::CachedValue, + T>; + std::variant, detail::CachedValue> m_task; public: DeferredComputation(task_type); + DeferredComputation(cached_type); + ~DeferredComputation(); auto get() -> T; auto operator()() -> T; + void forget() &&; + [[nodiscard]] auto valid() const noexcept -> bool; }; } // namespace openPMD::auxiliary diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 6e3c540d6b..f29502da04 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -9,62 +9,108 @@ #include "openPMD/DatatypeMacros.hpp" +namespace openPMD::auxiliary::detail +{ +template +auto OneTimeTask::operator()() -> T +{ + if (!this->m_task_valid) + { + throw std::runtime_error( + "[DeferredComputation] No valid state. Probably already " + "computed."); + } + if (!this->m_task) + { + throw std::runtime_error( + "[DeferredComputation] No valid task was specified."); + } + this->m_task_valid = false; + if constexpr (std::is_void_v) + { + std::move(this->m_task)(); + this->m_task = {}; + } + else + { + auto res = std::move(this->m_task)(); + this->m_task = {}; // reset + return res; + } +} +} // namespace openPMD::auxiliary::detail + namespace openPMD::auxiliary { template DeferredComputation::DeferredComputation(task_type task) - : m_task([wrapped_task = std::move(task), this]() { - if (!this->m_valid) - { - throw std::runtime_error( - "[DeferredComputation] No valid state. Probably already " - "computed."); - } - this->m_valid = false; - return std::move(wrapped_task)(); - }) - , m_valid(true) + : m_task(detail::OneTimeTask{std::move(task)}) {} template DeferredComputation::~DeferredComputation() { - if (m_valid) + try + { + std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) { + if (task.m_task_valid) + { + std::move(task)(); + } + }, + [](detail::CachedValue &) {}}, + this->m_task); + } + catch (std::exception const &e) + { + std::cerr << "[DeferredComputation] Error in destructor: '" << e.what() + << "'." << std::endl; + } + catch (...) { - try - { - get(); - } - catch (std::exception const &e) - { - std::cerr << "[DeferredComputation] Error in destructor: '" - << e.what() << "'." << std::endl; - } - catch (...) - { - std::cerr << "[DeferredComputation] Unknown error in destructor." - << std::endl; - } + std::cerr << "[DeferredComputation] Unknown error in destructor." + << std::endl; } } template auto DeferredComputation::get() -> T { - return m_task(); + return std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) -> T { return std::move(task)(); }, + [](detail::CachedValue &cached) -> T { + if constexpr (std::is_void_v) + { + return; + } + else + { + return cached.val; + } + }}, + this->m_task); } template auto DeferredComputation::operator()() -> T { - return m_task(); + return get(); } template auto DeferredComputation::valid() const noexcept -> bool { - return m_valid; + return std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask const &task) { + return task.m_task_valid; + }, + [](detail::CachedValue const &) { return true; }}, + this->m_task); } template class DeferredComputation; From c4e78a08a0f98aaf6159069de4d62d6677b2c9bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 19:06:18 +0200 Subject: [PATCH 34/47] Add unsafeNoAutomaticFlush --- include/openPMD/LoadStoreChunk.hpp | 18 ++++++++++ include/openPMD/RecordComponent.hpp | 3 +- src/LoadStoreChunk.cpp | 54 +++++++++++++++++++++++++++-- src/auxiliary/Future.cpp | 13 +++++++ 4 files changed, 84 insertions(+), 4 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 0e7ba3e6ae..0d31253ace 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -68,6 +68,8 @@ class ConfigureLoadStore std::optional m_offset; std::optional m_extent; + bool m_unsafeNoAutomaticFlush = false; + [[nodiscard]] auto dim() const -> uint8_t; auto storeChunkConfig() -> internal::LoadStoreConfig; @@ -86,6 +88,7 @@ class ConfigureLoadStore void offset_impl(Offset); void extent_impl(Extent); + void unsafeNoAutomaticFlush_impl(); private: auto withSharedPtr_impl_mut(std::shared_ptr data, Datatype) @@ -115,6 +118,11 @@ class ConfigureLoadStore extent_impl(std::move(extent)); return *this; } + auto unsafeNoAutomaticFlush() -> this_t & + { + unsafeNoAutomaticFlush_impl(); + return *this; + } /* * If the type is non-const, then the return type should be @@ -213,6 +221,11 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore extent_impl(std::move(extent)); return *this; } + auto unsafeNoAutomaticFlush() -> this_t & + { + unsafeNoAutomaticFlush_impl(); + return *this; + } auto memorySelection(MemorySelection memorySelection) -> this_t & { memorySelection_impl(std::move(memorySelection)); @@ -271,6 +284,11 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer extent_impl(std::move(extent)); return *this; } + auto unsafeNoAutomaticFlush() -> this_t & + { + unsafeNoAutomaticFlush_impl(); + return *this; + } auto memorySelection(MemorySelection memorySelection) -> this_t & { memorySelection_impl(std::move(memorySelection)); diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index 3150c94535..0f8c4b4c09 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -129,7 +129,8 @@ class RecordComponent : public BaseRecordComponent friend class ConfigureLoadStore; friend class ConfigureLoadStoreFromBuffer; friend class ConfigureStoreChunkFromBuffer; - friend struct VisitorEnqueueLoadVariant; + friend struct VisitorEnqueueLoadVariantWithoutFlush; + friend struct VisitorEnqueueLoadVariantWithFlush; friend struct VisitorLoadVariant; public: diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index 161a6b0455..dc354579be 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -2,8 +2,10 @@ #include "openPMD/LoadStoreChunk.hpp" #include "openPMD/Datatype.hpp" +#include "openPMD/Error.hpp" #include "openPMD/RecordComponent.hpp" #include "openPMD/Span.hpp" +#include "openPMD/auxiliary/Future.hpp" #include "openPMD/auxiliary/Memory.hpp" #include "openPMD/auxiliary/Memory_internal.hpp" #include "openPMD/auxiliary/ShareRawInternal.hpp" @@ -70,6 +72,12 @@ auto ConfigureLoadStore::storeChunkConfig() -> internal::LoadStoreConfig auto ConfigureLoadStore::deferFlush(Attributable &attr) { + if (m_unsafeNoAutomaticFlush) + { + throw error::Internal( + "Configuring an automatic flush operating after configuring that " + "those should be switched off."); + } auto index = attr.IOHandler()->m_flushCounter; return [attr, old_index = *index, @@ -221,6 +229,11 @@ auto ConfigureLoadStore::load() -> auxiliary::DeferredComputation> { auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); + if (m_unsafeNoAutomaticFlush) + { + return auxiliary::DeferredComputation>( + std::move(res)); + } return auxiliary::DeferredComputation>( [res_lambda = std::move(res), dflush = deferFlush(m_rc)]() mutable { dflush(); @@ -243,7 +256,7 @@ auto ConfigureLoadStore::loadRaw(EnqueuePolicy ep) -> std::shared_ptr return res; } -struct VisitorEnqueueLoadVariant +struct VisitorEnqueueLoadVariantWithFlush { template static auto @@ -262,12 +275,32 @@ struct VisitorEnqueueLoadVariant }); } }; +struct VisitorEnqueueLoadVariantWithoutFlush +{ + template + static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) + -> auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types> + { + auto res = rc.loadChunkAllocate_impl(std::move(cfg)); + return auxiliary::DeferredComputation< + auxiliary::detail::shared_ptr_dataset_types>(std::move(res)); + } +}; auto ConfigureLoadStore::loadVariant() -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types> { - return m_rc.visit( - this->storeChunkConfig(), deferFlush(m_rc)); + if (m_unsafeNoAutomaticFlush) + { + return m_rc.visit( + this->storeChunkConfig()); + } + else + { + return m_rc.visit( + this->storeChunkConfig(), deferFlush(m_rc)); + } } struct VisitorLoadVariant @@ -314,6 +347,11 @@ auto ConfigureStoreChunkFromBuffer::store() { this->m_rc.storeChunk_impl( std::move(m_buffer), m_datatype, storeChunkConfig()); + if (m_unsafeNoAutomaticFlush) + { + return auxiliary::DeferredComputation( + auxiliary::detail::CachedValue()); + } return auxiliary::DeferredComputation( [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); } @@ -345,6 +383,11 @@ auto ConfigureLoadStoreFromBuffer::load() } this->m_rc.loadChunk_impl( *shared_ptr, m_datatype, this->storeChunkConfig()); + if (m_unsafeNoAutomaticFlush) + { + return auxiliary::DeferredComputation( + auxiliary::detail::CachedValue()); + } return auxiliary::DeferredComputation( [dflush = this->deferFlush(this->m_rc)]() mutable -> void { dflush(); @@ -384,6 +427,11 @@ void ConfigureLoadStore::offset_impl(Offset offset) m_offset = std::make_optional(std::move(offset)); } +void ConfigureLoadStore::unsafeNoAutomaticFlush_impl() +{ + m_unsafeNoAutomaticFlush = true; +} + void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) { m_mem_select = std::make_optional(std::move(sel)); diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index f29502da04..4cb28a9dc3 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -101,6 +101,19 @@ auto DeferredComputation::operator()() -> T return get(); } +template +void DeferredComputation::forget() && +{ + std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) { + task.m_task = {}; + task.m_task_valid = false; + }, + [](detail::CachedValue const &) {}}, + this->m_task); +} + template auto DeferredComputation::valid() const noexcept -> bool { From 6b09c1d80f6df97c12dcf35c34d0e1c1fb18e2b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 19:11:39 +0200 Subject: [PATCH 35/47] add missing constructor --- src/auxiliary/Future.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 4cb28a9dc3..9a9890e98e 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -48,6 +48,11 @@ DeferredComputation::DeferredComputation(task_type task) : m_task(detail::OneTimeTask{std::move(task)}) {} +template +DeferredComputation::DeferredComputation(cached_type cached_val) + : m_task(detail::CachedValue{std::move(cached_val)}) +{} + template DeferredComputation::~DeferredComputation() { From 18e6b68fe5341c3ff0f8f4958e8be930e6274d58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 19:15:55 +0200 Subject: [PATCH 36/47] remove internal use of raw methods --- include/openPMD/RecordComponent.tpp | 6 ++++-- src/RecordComponent.cpp | 19 ++++++++++++------- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp index cf6224c68c..f5d31f1faa 100644 --- a/include/openPMD/RecordComponent.tpp +++ b/include/openPMD/RecordComponent.tpp @@ -47,7 +47,8 @@ RecordComponent::storeChunk(std::unique_ptr data, Offset o, Extent e) .offset(std::move(o)) .extent(std::move(e)) .withUniquePtr(std::move(data)) - .storeRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .store(); } template @@ -69,7 +70,8 @@ RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e) std::move(storeChunkConfig) .withContiguousContainer(data) - .storeRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .store(); } template diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index 81578d6d18..a1a4680154 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -254,7 +254,8 @@ std::shared_ptr RecordComponent::loadChunkAllocate_impl( .offset(std::move(o)) .extent(std::move(e)) .withSharedPtr_impl_mut(newData, dtype) - .loadRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .load(); return newData; } @@ -852,7 +853,7 @@ std::shared_ptr RecordComponent::loadChunk(Offset o, Extent e) operation.extent(std::move(e)); } - return operation.loadRaw(EnqueuePolicy::Defer); + return operation.unsafeNoAutomaticFlush().load().get(); } namespace detail @@ -993,7 +994,7 @@ void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) operation.extent(std::move(e)); } - operation.withSharedPtr(std::move(data)).loadRaw(EnqueuePolicy::Defer); + operation.withSharedPtr(std::move(data)).unsafeNoAutomaticFlush().load(); } template @@ -1003,7 +1004,8 @@ void RecordComponent::loadChunkRaw(T *ptr, Offset offset, Extent extent) .offset(std::move(offset)) .extent(std::move(extent)) .withRawPtr(ptr) - .loadRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .load(); } template @@ -1013,7 +1015,8 @@ void RecordComponent::storeChunk(std::shared_ptr data, Offset o, Extent e) .offset(std::move(o)) .extent(std::move(e)) .withSharedPtr(std::move(data)) - .storeRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .store(); } template @@ -1024,7 +1027,8 @@ void RecordComponent::storeChunk( .offset(std::move(o)) .extent(std::move(e)) .withUniquePtr(std::move(data)) - .storeRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .store(); } template @@ -1034,7 +1038,8 @@ void RecordComponent::storeChunkRaw(T const *ptr, Offset offset, Extent extent) .offset(std::move(offset)) .extent(std::move(extent)) .withRawPtr(ptr) - .storeRaw(EnqueuePolicy::Defer); + .unsafeNoAutomaticFlush() + .store(); } template From 21c024c3b96ba331d62c445f31b08e9a39a0ee91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 7 Apr 2026 19:19:10 +0200 Subject: [PATCH 37/47] Remove raw methods --- include/openPMD/LoadStoreChunk.hpp | 32 -------------- src/LoadStoreChunk.cpp | 71 +----------------------------- 2 files changed, 1 insertion(+), 102 deletions(-) diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 0d31253ace..7d194fab22 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -45,12 +45,6 @@ namespace auxiliary::detail #undef OPENPMD_ENUMERATE_TYPES } // namespace auxiliary::detail -enum class EnqueuePolicy : std::uint8_t -{ - Defer, - Immediate -}; - /* * Actual data members of `ConfigureLoadStore<>` and methods that don't * depend on the ChildClass template parameter. By extracting the members to @@ -174,20 +168,11 @@ class ConfigureLoadStore [[nodiscard]] auto loadVariant() -> auxiliary::DeferredComputation< auxiliary::detail::shared_ptr_dataset_types>; - -private: - // Direct execution methods (with EnqueuePolicy) - template - [[nodiscard]] auto loadRaw(EnqueuePolicy) -> std::shared_ptr; - - [[nodiscard]] auto loadVariantRaw(EnqueuePolicy) - -> auxiliary::detail::shared_ptr_dataset_types; }; class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore { friend class ConfigureLoadStore; - friend class RecordComponent; protected: auxiliary::WriteBuffer m_buffer; @@ -248,19 +233,6 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore "Cannot load chunk data into a buffer that is const or a " "unique_ptr."); } - -private: - // Direct execution method (with EnqueuePolicy) - auto storeRaw(EnqueuePolicy) -> void; - - template - auto loadRaw(EnqueuePolicy) - { - static_assert( - auxiliary::dependent_false_v, - "Cannot load chunk data into a buffer that is const or a " - "unique_ptr."); - } }; class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer @@ -297,10 +269,6 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer // Enqueue method (deferred execution) auto load() -> auxiliary::DeferredComputation; - -private: - // Direct execution method (with EnqueuePolicy) - auto loadRaw(EnqueuePolicy) -> void; }; } // namespace openPMD diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp index dc354579be..6a8c526be6 100644 --- a/src/LoadStoreChunk.cpp +++ b/src/LoadStoreChunk.cpp @@ -241,21 +241,6 @@ auto ConfigureLoadStore::load() }); } -template -auto ConfigureLoadStore::loadRaw(EnqueuePolicy ep) -> std::shared_ptr -{ - auto res = m_rc.loadChunkAllocate_impl(storeChunkConfig()); - switch (ep) - { - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - m_rc.seriesFlush(); - break; - } - return res; -} - struct VisitorEnqueueLoadVariantWithFlush { template @@ -313,21 +298,6 @@ struct VisitorLoadVariant } }; -auto ConfigureLoadStore::loadVariantRaw(EnqueuePolicy ep) - -> auxiliary::detail::shared_ptr_dataset_types -{ - auto res = m_rc.visit(this->storeChunkConfig()); - switch (ep) - { - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - m_rc.seriesFlush(); - break; - } - return res; -} - ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer( auxiliary::WriteBuffer buffer, Datatype dt, ConfigureLoadStore &&core) : ConfigureLoadStore(std::move(core)) @@ -356,20 +326,6 @@ auto ConfigureStoreChunkFromBuffer::store() [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); }); } -auto ConfigureStoreChunkFromBuffer::storeRaw(EnqueuePolicy ep) -> void -{ - this->m_rc.storeChunk_impl( - std::move(m_buffer), m_datatype, storeChunkConfig()); - switch (ep) - { - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - m_rc.seriesFlush(); - break; - } -} - auto ConfigureLoadStoreFromBuffer::load() -> auxiliary::DeferredComputation { @@ -394,29 +350,6 @@ auto ConfigureLoadStoreFromBuffer::load() }); } -auto ConfigureLoadStoreFromBuffer::loadRaw(EnqueuePolicy ep) -> void -{ - auto *shared_ptr = std::get_if( - &this->m_buffer.as_variant()); - if (!shared_ptr) - { - throw std::runtime_error( - "ConfigureLoadStoreFromBuffer must be instantiated with a " - "non-const shared_ptr type."); - } - this->m_rc.loadChunk_impl( - *shared_ptr, m_datatype, this->storeChunkConfig()); - switch (ep) - { - - case EnqueuePolicy::Defer: - break; - case EnqueuePolicy::Immediate: - this->m_rc.seriesFlush(); - break; - } -} - void ConfigureLoadStore::extent_impl(Extent extent) { m_extent = std::make_optional(std::move(extent)); @@ -446,9 +379,7 @@ void ConfigureStoreChunkFromBuffer::memorySelection_impl(MemorySelection sel) #define INSTANTIATE_METHOD_TEMPLATES(dtype) \ template auto ConfigureLoadStore::load() \ -> auxiliary::DeferredComputation; \ - template auto ConfigureLoadStore::loadRaw(EnqueuePolicy) \ - ->std::shared_ptr; + std::shared_ptr, dtype)>; #define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ INSTANTIATE_METHOD_TEMPLATES(type) \ INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type)) \ From fdd089829cf872ef85feb059d54a7db890ade646 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Wed, 8 Apr 2026 10:28:49 +0200 Subject: [PATCH 38/47] Avoid if constexpr, msvc doesnt get it --- src/auxiliary/Future.cpp | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 9a9890e98e..5607cf0589 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -87,16 +87,17 @@ auto DeferredComputation::get() -> T return std::visit( auxiliary::overloaded{ [](detail::OneTimeTask &task) -> T { return std::move(task)(); }, - [](detail::CachedValue &cached) -> T { - if constexpr (std::is_void_v) - { - return; - } - else - { - return cached.val; - } - }}, + [](detail::CachedValue &cached) -> T { return cached.val; }}, + this->m_task); +} + +template <> +auto DeferredComputation::get() -> void +{ + std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) { std::move(task)(); }, + [](detail::CachedValue &) { return; }}, this->m_task); } From b212a9aa6875fd0179f371f2c88d0e248a0207c6 Mon Sep 17 00:00:00 2001 From: AI Agent Date: Wed, 8 Apr 2026 08:37:53 +0000 Subject: [PATCH 39/47] Add Doxygen documentation to new functions and types --- include/openPMD/Dataset.hpp | 6 ++ include/openPMD/Datatype.hpp | 60 ++++++++++- include/openPMD/IO/ADIOS/ADIOS2File.hpp | 2 + include/openPMD/IO/ADIOS/macros.hpp | 5 + include/openPMD/IO/AbstractIOHandler.hpp | 13 +++ include/openPMD/IO/IOTask.hpp | 4 +- include/openPMD/IO/InvalidatableFile.hpp | 5 + include/openPMD/Iteration.hpp | 6 ++ include/openPMD/LoadStoreChunk.hpp | 126 ++++++++++++++++++++++- include/openPMD/ParticleSpecies.hpp | 4 + include/openPMD/RecordComponent.hpp | 8 ++ include/openPMD/auxiliary/Defer.hpp | 20 ++++ include/openPMD/auxiliary/Future.hpp | 40 +++++++ src/Datatype.cpp | 7 -- 14 files changed, 295 insertions(+), 11 deletions(-) diff --git a/include/openPMD/Dataset.hpp b/include/openPMD/Dataset.hpp index 27195abb4d..b8af286e14 100644 --- a/include/openPMD/Dataset.hpp +++ b/include/openPMD/Dataset.hpp @@ -34,6 +34,12 @@ namespace openPMD using Extent = std::vector; using Offset = std::vector; +/** Selection of a region of memory for storing chunks. + * + * Used to specify a non-contiguous memory region when storing + * data chunks. This allows writing data that is not contiguous + * in memory. + */ struct MemorySelection { Offset offset; diff --git a/include/openPMD/Datatype.hpp b/include/openPMD/Datatype.hpp index 17cf6b67f4..2a2413975f 100644 --- a/include/openPMD/Datatype.hpp +++ b/include/openPMD/Datatype.hpp @@ -420,6 +420,11 @@ inline size_t toBits(Datatype d) return toBytes(d) * CHAR_BIT; } +/** Check if a Datatype is a signed type + * + * @param d Datatype to test + * @return true if signed type (integer, floating point, complex), else false + */ constexpr bool isSigned(Datatype d); /** Compare if a Datatype is a vector type @@ -602,6 +607,13 @@ inline bool isSameFloatingPoint(Datatype d) return isSameFloatingPoint(d, determineDatatype()); } +/** Compare if two Datatypes are equivalent floating point types + * + * @param d1 First Datatype to compare + * @param d2 Second Datatype to compare + * @return true if both types are floating point and have same bitness, else + * false + */ inline bool isSameFloatingPoint(Datatype d1, Datatype d2) { // template @@ -629,6 +641,13 @@ inline bool isSameComplexFloatingPoint(Datatype d) return isSameComplexFloatingPoint(d, determineDatatype()); } +/** Compare if two Datatypes are equivalent complex floating point types + * + * @param d1 First Datatype to compare + * @param d2 Second Datatype to compare + * @return true if both types are complex floating point and have same bitness, + * else false + */ inline bool isSameComplexFloatingPoint(Datatype d1, Datatype d2) { // template @@ -656,6 +675,13 @@ inline bool isSameInteger(Datatype d) return isSameInteger(d, determineDatatype()); } +/** Compare if two Datatypes are equivalent integer types + * + * @param d1 First Datatype to compare + * @param d2 Second Datatype to compare + * @return true if both types are integers, same signedness and same bitness, + * else false + */ inline bool isSameInteger(Datatype d1, Datatype d2) { // template @@ -708,6 +734,13 @@ constexpr bool isChar(Datatype d) template constexpr bool isSameChar(Datatype d); +/** Compare if two Datatypes are equivalent char types + * + * @param d1 First Datatype to compare + * @param d2 Second Datatype to compare + * @return true if both types are chars with same signedness and size, else + * false + */ constexpr bool isSameChar(Datatype d1, Datatype d2); /** Comparison for two Datatypes @@ -715,6 +748,10 @@ constexpr bool isSameChar(Datatype d1, Datatype d2); * Besides returning true for the same types, identical implementations on * some platforms, e.g. if long and long long are the same or double and * long double will also return true. + * + * @param d First Datatype to compare + * @param e Second Datatype to compare + * @return true if the datatypes are equivalent */ constexpr bool isSame(openPMD::Datatype d, openPMD::Datatype e); @@ -726,14 +763,33 @@ constexpr bool isSame(openPMD::Datatype d, openPMD::Datatype e); */ Datatype basicDatatype(Datatype dt); +/** Convert a scalar Datatype to its vector variant + * + * @param dt Scalar Datatype to convert + * @return Vector Datatype (e.g., INT becomes VEC_INT) + */ Datatype toVectorType(Datatype dt); +/** Convert a Datatype to its string representation + * + * @param dt Datatype to convert + * @return String representation of the Datatype + */ std::string datatypeToString(Datatype dt); +/** Convert a string to a Datatype + * + * @param s String representation of a Datatype + * @return The corresponding Datatype + */ Datatype stringToDatatype(const std::string &s); -void warnWrongDtype(std::string const &key, Datatype store, Datatype request); - +/** Stream operator for Datatype + * + * @param os Output stream + * @param dt Datatype to output + * @return Reference to the stream + */ std::ostream &operator<<(std::ostream &, openPMD::Datatype const &); template diff --git a/include/openPMD/IO/ADIOS/ADIOS2File.hpp b/include/openPMD/IO/ADIOS/ADIOS2File.hpp index 0b7aa6f314..66aa47e702 100644 --- a/include/openPMD/IO/ADIOS/ADIOS2File.hpp +++ b/include/openPMD/IO/ADIOS/ADIOS2File.hpp @@ -108,11 +108,13 @@ struct WriteDataset static void call(Params &&...); }; +/** Buffered put operation with unique pointer */ struct BufferedUniquePtrPut { std::string name; Offset offset; Extent extent; + /** Optional memory selection for non-contiguous memory regions */ std::optional memorySelection; UniquePtrWithLambda data; Datatype dtype = Datatype::UNDEFINED; diff --git a/include/openPMD/IO/ADIOS/macros.hpp b/include/openPMD/IO/ADIOS/macros.hpp index dd33af3b0b..2f09b47636 100644 --- a/include/openPMD/IO/ADIOS/macros.hpp +++ b/include/openPMD/IO/ADIOS/macros.hpp @@ -50,6 +50,10 @@ namespace openPMD { namespace detail { + /** Trait to check if a variable supports SetMemorySelection + * + * @tparam Variable ADIOS2 variable type + */ template struct CanTheMemorySelectionBeReset { @@ -65,6 +69,7 @@ namespace detail }; } // namespace detail +/** Whether ADIOS2 Variable supports SetMemorySelection */ constexpr bool CanTheMemorySelectionBeReset = detail::CanTheMemorySelectionBeReset>::value; } // namespace openPMD diff --git a/include/openPMD/IO/AbstractIOHandler.hpp b/include/openPMD/IO/AbstractIOHandler.hpp index 6429328c22..086a6e6cfa 100644 --- a/include/openPMD/IO/AbstractIOHandler.hpp +++ b/include/openPMD/IO/AbstractIOHandler.hpp @@ -265,6 +265,12 @@ class AbstractIOHandler * backends that decide to implement this operation asynchronously. */ std::future flush(internal::FlushParams const &); + /** Counter tracking the number of flush operations. This is later used to + * avoid repeated flushing in the DeferredComputation objects returned by + * the loadStoreChunk() API. (The counter is copied as a weak reference to + * the shared pointer, and the value is compared to the value upon enqueuing + * the operation. If the flush counter has proceeded past the old value, our + * operation has already been run.) */ std::shared_ptr m_flushCounter = std::make_shared(0); @@ -319,6 +325,13 @@ class AbstractIOHandler bool m_verify_homogeneous_extents = true; protected: + /** Implementation of flush operation for subclasses + * + * Do not call directly, use flush() wrapper instead. + * + * @param params Parsed flush parameters + * @return Future indicating completion state + */ virtual std::future flush_impl(internal::ParsedFlushParams &) = 0; }; // AbstractIOHandler diff --git a/include/openPMD/IO/IOTask.hpp b/include/openPMD/IO/IOTask.hpp index 636140f04f..e85e9c6777 100644 --- a/include/openPMD/IO/IOTask.hpp +++ b/include/openPMD/IO/IOTask.hpp @@ -495,6 +495,7 @@ struct OPENPMDAPI_EXPORT Extent extent = {}; Offset offset = {}; + /** Optional memory selection for non-contiguous memory regions */ std::optional memorySelection = std::nullopt; Datatype dtype = Datatype::UNDEFINED; auxiliary::WriteBuffer data; @@ -559,7 +560,8 @@ struct OPENPMDAPI_EXPORT } // in parameters - bool queryOnly = false; // query if the backend supports this + /** If true, only query if the backend supports buffer views without performing operation */ + bool queryOnly = false; Offset offset; Extent extent; Datatype dtype = Datatype::UNDEFINED; diff --git a/include/openPMD/IO/InvalidatableFile.hpp b/include/openPMD/IO/InvalidatableFile.hpp index 6ac0051cbe..e5008b5fb5 100644 --- a/include/openPMD/IO/InvalidatableFile.hpp +++ b/include/openPMD/IO/InvalidatableFile.hpp @@ -83,6 +83,11 @@ struct hash result_type operator()(argument_type const &s) const noexcept; }; +/** Specialization of std::less for InvalidatableFile + * + * Enables using InvalidatableFile in ordered containers like std::set + * for consistent ordering across parallel processes. + */ template <> struct less { diff --git a/include/openPMD/Iteration.hpp b/include/openPMD/Iteration.hpp index abce61eef7..38ee56f7ad 100644 --- a/include/openPMD/Iteration.hpp +++ b/include/openPMD/Iteration.hpp @@ -454,6 +454,12 @@ class Iteration : public Attributable namespace traits { + /** Generation policy for Iteration objects. + * + * This policy populates the cached iteration index when an Iteration + * is created or inserted into a Series, enabling constant-time lookup + * of the owning map entry. + */ template <> struct GenerationPolicy { diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp index 7d194fab22..89983ab0fe 100644 --- a/include/openPMD/LoadStoreChunk.hpp +++ b/include/openPMD/LoadStoreChunk.hpp @@ -22,11 +22,18 @@ class Attributable; namespace internal { + /** Internal configuration for load/store operations without buffer. Default + * values for optionally specified parameters (offset, extent) must be + * computed to create this configuration struct. */ struct LoadStoreConfig { Offset offset; Extent extent; }; + /** Internal configuration for load/store operations with buffer. Default + * values for optionally specified parameters (offset, extent) must be + * computed to create this configuration struct. MemorySelection remains + * optional even then. */ struct LoadStoreConfigWithBuffer { Offset offset; @@ -45,7 +52,8 @@ namespace auxiliary::detail #undef OPENPMD_ENUMERATE_TYPES } // namespace auxiliary::detail -/* +/** Base class for configuring load/store chunk operations. + * * Actual data members of `ConfigureLoadStore<>` and methods that don't * depend on the ChildClass template parameter. By extracting the members to * this struct, we can pass them around between different instances of the @@ -102,16 +110,41 @@ class ConfigureLoadStore using this_t = ConfigureLoadStore; // Configuration methods (always available) + + /** Set the offset within the dataset + * + * Optional. The operation will apply without offset by default (i.e. offset + * = (0, 0, ...)). + * + * @param offset Offset within the dataset + * @return Reference to this object for chaining + */ auto offset(Offset offset) -> this_t & { offset_impl(std::move(offset)); return *this; } + /** Set the extent within the dataset + * + * Optional. The operation will apply to the entire dataset by default (i.e. + * operation extent = global dataset extent - operation offset). + * + * @param extent Extent within the dataset, counted from the offset + * @return Reference to this object for chaining + */ auto extent(Extent extent) -> this_t & { extent_impl(std::move(extent)); return *this; } + /** Disable automatic flush after store operation + * + * The returned objects of type DeferredComputation will still return a + * buffer upon get() / operator()(), but these buffers are not guaranteed to + * be filled until explicitly flushing. + * + * @return Reference to this object for chaining + */ auto unsafeNoAutomaticFlush() -> this_t & { unsafeNoAutomaticFlush_impl(); @@ -170,6 +203,14 @@ class ConfigureLoadStore auxiliary::detail::shared_ptr_dataset_types>; }; +/** Configuration for storing chunks from a buffer. + * + * This class is used to configure a store chunk operation, where data is + * stored from a provided buffer into a dataset. + * This class is distinct from ConfigureLoadStoreFromBuffer, since reading + * data does not make sense on const / unique pointer types. This way, the type + * system will only allow read operations where they can actually run. + */ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore { friend class ConfigureLoadStore; @@ -188,6 +229,8 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore // class should be returned. Could be solved more elegantly with CRT, // but that blows up compile-time, so we make internal void functions // and then repeat them in the final classes. + + /** Set memory selection for non-contiguous memory regions */ void memorySelection_impl(MemorySelection); auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; @@ -196,21 +239,54 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore using this_t = ConfigureStoreChunkFromBuffer; // Configuration methods (always available) + + /** Set the offset within the dataset + * + * Optional. The operation will apply without offset by default (i.e. offset + * = (0, 0, ...)). + * + * @param offset Offset within the dataset + * @return Reference to this object for chaining + */ auto offset(Offset offset) -> this_t & { offset_impl(std::move(offset)); return *this; } + + /** Set the extent within the dataset + * + * Optional. The operation will apply to the entire dataset by default (i.e. + * operation extent = global dataset extent - operation offset). + * + * @param extent Extent within the dataset, counted from the offset + * @return Reference to this object for chaining + */ auto extent(Extent extent) -> this_t & { extent_impl(std::move(extent)); return *this; } + + /** Disable automatic flush after store operation + * + * The returned objects of type DeferredComputation will still return a + * buffer upon get() / operator()(), but these buffers are not guaranteed to + * be filled until explicitly flushing. + * + * @return Reference to this object for chaining + */ auto unsafeNoAutomaticFlush() -> this_t & { unsafeNoAutomaticFlush_impl(); return *this; } + + /** Set memory selection for non-contiguous memory regions + * + * @param memorySelection Selection of memory region + * @return Reference to this object for chaining + */ auto memorySelection(MemorySelection memorySelection) -> this_t & { memorySelection_impl(std::move(memorySelection)); @@ -218,6 +294,11 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore } // Enqueue method (deferred execution) + + /** Store the chunk data + * + * @return Deferred computation that performs the store when invoked + */ auto store() -> auxiliary::DeferredComputation; /** This intentionally shadows the parent class's enqueueLoad methods in @@ -235,6 +316,11 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore } }; +/** Configuration for loading/storing chunks from/to a buffer. + * + * This class supports both loading and storing operations, allowing + * reading data into or writing data from a provided buffer. + */ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer { friend class ConfigureLoadStore; @@ -246,21 +332,54 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer using this_t = ConfigureLoadStoreFromBuffer; // Configuration methods (always available) + + /** Set the offset within the dataset + * + * Optional. The operation will apply without offset by default (i.e. offset + * = (0, 0, ...)). + * + * @param offset Offset within the dataset + * @return Reference to this object for chaining + */ auto offset(Offset offset) -> this_t & { offset_impl(std::move(offset)); return *this; } + + /** Set the extent within the dataset + * + * Optional. The operation will apply to the entire dataset by default (i.e. + * operation extent = global dataset extent - operation offset). + * + * @param extent Extent within the dataset, counted from the offset + * @return Reference to this object for chaining + */ auto extent(Extent extent) -> this_t & { extent_impl(std::move(extent)); return *this; } + + /** Disable automatic flush after operation + * + * The returned objects of type DeferredComputation will still return a + * buffer upon get() / operator()(), but these buffers are not guaranteed to + * be filled until explicitly flushing. + * + * @return Reference to this object for chaining + */ auto unsafeNoAutomaticFlush() -> this_t & { unsafeNoAutomaticFlush_impl(); return *this; } + + /** Set memory selection for non-contiguous memory regions + * + * @param memorySelection Selection of memory region + * @return Reference to this object for chaining + */ auto memorySelection(MemorySelection memorySelection) -> this_t & { memorySelection_impl(std::move(memorySelection)); @@ -268,6 +387,11 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer } // Enqueue method (deferred execution) + + /** Load the chunk data into the buffer + * + * @return Deferred computation that performs the load when invoked + */ auto load() -> auxiliary::DeferredComputation; }; diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp index 7309afddef..51ecd26fcf 100644 --- a/include/openPMD/ParticleSpecies.hpp +++ b/include/openPMD/ParticleSpecies.hpp @@ -57,6 +57,10 @@ class ParticleSpecies : public Container namespace traits { + /** Generation policy for ParticleSpecies objects. + * + * Links particle patches to their parent hierarchy when a species is created. + */ template <> struct GenerationPolicy { diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp index 0f8c4b4c09..58cfee1478 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -218,6 +218,14 @@ class RecordComponent : public BaseRecordComponent */ bool empty() const; + /** Prepare a load/store chunk configuration object + * + * This is the entry point for the experimental new API for loading and + * storing chunks. It returns a ConfigureLoadStore object that can be used + * to specify offset, extent, and buffer for the operation. + * + * @return ConfigureLoadStore object for configuring the operation + */ ConfigureLoadStore prepareLoadStore(); /** Load and allocate a chunk of data diff --git a/include/openPMD/auxiliary/Defer.hpp b/include/openPMD/auxiliary/Defer.hpp index c6bc4e0533..804e775c70 100644 --- a/include/openPMD/auxiliary/Defer.hpp +++ b/include/openPMD/auxiliary/Defer.hpp @@ -6,6 +6,17 @@ namespace openPMD::auxiliary { +/** Defer wrapper + * + * Executes a functor when destroyed unless explicitly cancelled. + * Similar to Go's defer or C++'s experimental::scope_exit. + * + * Similar also to DeferredComputation under Future.hpp, but has another + * application scope (this: internal resource cleanup, that: public Future-like + * API) and is hence kept separate. + * + * @tparam F The functor type + */ template struct defer_type { @@ -48,8 +59,17 @@ struct defer_type auto operator=(defer_type const &) -> defer_type & = delete; }; +/** Type-erased defer wrapper for void functors */ using opaque_defer_type = defer_type>; +/** Create a defer wrapper + * + * Creates a defer wrapper that will execute the given functor when + * destroyed. + * + * @param functor The functor to execute on destruction + * @return A defer wrapper + */ template auto defer(F &&functor) -> defer_type> { diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index 15186a85df..770504f155 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -5,6 +5,7 @@ namespace openPMD::auxiliary::detail { +/** Internal helper for deferred computation - executes task once */ template struct OneTimeTask { @@ -15,6 +16,9 @@ struct OneTimeTask auto operator()() -> T; }; +/** Internal helper for cached value storage. Used when the API requires + * creation of a DeferredComputation object, but there is not actually a + * computation to run. */ template struct CachedValue { @@ -29,6 +33,19 @@ struct CachedValue namespace openPMD::auxiliary { +/** A computation that is deferred until explicitly invoked. + * + * This class wraps a callable, allowing lazy evaluation. + * The computation is performed once on first invocation, repeated invocation is + * an error. Check if the computation is still valid by calling valid(). + * + * Note: Some API operations may construct a DeferredComputation without any + * actual computation, instead emplacing a cached value. This is treated + * transparently to the user. In this case however, the object will not turn + * invalid upon invocation. + * + * @tparam T The return type of the computation + */ template class DeferredComputation { @@ -41,16 +58,39 @@ class DeferredComputation std::variant, detail::CachedValue> m_task; public: + /** Construct from a callable + * + * @param task The callable to execute + */ DeferredComputation(task_type); + /** Construct from a cached value + * + * @param val The pre-computed value + */ DeferredComputation(cached_type); ~DeferredComputation(); + /** Get the result of the computation + * + * @return The result of the computation + */ auto get() -> T; + /** Invoke the computation + * + * Alias for get() + * @return The result of the computation + */ auto operator()() -> T; + /** Discard the computation without executing it + */ void forget() &&; + /** Check if the computation is valid + * + * @return true if the computation has not been forgotten + */ [[nodiscard]] auto valid() const noexcept -> bool; }; } // namespace openPMD::auxiliary diff --git a/src/Datatype.cpp b/src/Datatype.cpp index 479286066c..ead2859c81 100644 --- a/src/Datatype.cpp +++ b/src/Datatype.cpp @@ -29,13 +29,6 @@ namespace openPMD { -void warnWrongDtype(std::string const &key, Datatype store, Datatype request) -{ - std::cerr << "Warning: Attribute '" << key << "' stored as " << store - << ", requested as " << request - << ". Casting unconditionally with possible loss of precision.\n"; -} - std::ostream &operator<<(std::ostream &os, openPMD::Datatype const &d) { using DT = openPMD::Datatype; From d542cb3c4fb6ffb3be163f74b47b5ab06278dbab Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 8 Apr 2026 09:24:07 +0000 Subject: [PATCH 40/47] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- include/openPMD/IO/IOTask.hpp | 3 ++- include/openPMD/ParticleSpecies.hpp | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/include/openPMD/IO/IOTask.hpp b/include/openPMD/IO/IOTask.hpp index e85e9c6777..662a34f9e3 100644 --- a/include/openPMD/IO/IOTask.hpp +++ b/include/openPMD/IO/IOTask.hpp @@ -560,7 +560,8 @@ struct OPENPMDAPI_EXPORT } // in parameters - /** If true, only query if the backend supports buffer views without performing operation */ + /** If true, only query if the backend supports buffer views without + * performing operation */ bool queryOnly = false; Offset offset; Extent extent; diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp index 51ecd26fcf..2c38a0cfe1 100644 --- a/include/openPMD/ParticleSpecies.hpp +++ b/include/openPMD/ParticleSpecies.hpp @@ -59,7 +59,8 @@ namespace traits { /** Generation policy for ParticleSpecies objects. * - * Links particle patches to their parent hierarchy when a species is created. + * Links particle patches to their parent hierarchy when a species is + * created. */ template <> struct GenerationPolicy From af17c0efc41e93b7fa15b88df678bdfc7a9213aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Wed, 8 Apr 2026 13:46:58 +0200 Subject: [PATCH 41/47] CI fixes --- include/openPMD/Datatype.hpp | 2 +- include/openPMD/IO/AbstractIOHandler.hpp | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/include/openPMD/Datatype.hpp b/include/openPMD/Datatype.hpp index 2a2413975f..3f667ae47f 100644 --- a/include/openPMD/Datatype.hpp +++ b/include/openPMD/Datatype.hpp @@ -790,7 +790,7 @@ Datatype stringToDatatype(const std::string &s); * @param dt Datatype to output * @return Reference to the stream */ -std::ostream &operator<<(std::ostream &, openPMD::Datatype const &); +std::ostream &operator<<(std::ostream &os, openPMD::Datatype const &dt); template constexpr auto datatypeIndex() -> size_t diff --git a/include/openPMD/IO/AbstractIOHandler.hpp b/include/openPMD/IO/AbstractIOHandler.hpp index 086a6e6cfa..eccb73d742 100644 --- a/include/openPMD/IO/AbstractIOHandler.hpp +++ b/include/openPMD/IO/AbstractIOHandler.hpp @@ -332,7 +332,8 @@ class AbstractIOHandler * @param params Parsed flush parameters * @return Future indicating completion state */ - virtual std::future flush_impl(internal::ParsedFlushParams &) = 0; + virtual std::future + flush_impl(internal::ParsedFlushParams ¶ms) = 0; }; // AbstractIOHandler } // namespace openPMD From 4110819c873e6269d48fbd7a8f1b8c2d8c409bf9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 14 Apr 2026 18:01:01 +0200 Subject: [PATCH 42/47] Documentation fixes --- include/openPMD/auxiliary/Future.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index 770504f155..c1cc2c0c12 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -62,12 +62,12 @@ class DeferredComputation * * @param task The callable to execute */ - DeferredComputation(task_type); + DeferredComputation(task_type task); /** Construct from a cached value * * @param val The pre-computed value */ - DeferredComputation(cached_type); + DeferredComputation(cached_type val); ~DeferredComputation(); From d5bab60aaa516e2cf3a4d54e7094c058f0cbe4e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 20 Apr 2026 18:13:35 +0200 Subject: [PATCH 43/47] AI code review --- include/openPMD/IO/InvalidatableFile.hpp | 4 +++- include/openPMD/auxiliary/Future.hpp | 10 ++++++++++ src/IO/AbstractIOHandler.cpp | 6 +++++- src/auxiliary/Future.cpp | 11 +++++++++++ 4 files changed, 29 insertions(+), 2 deletions(-) diff --git a/include/openPMD/IO/InvalidatableFile.hpp b/include/openPMD/IO/InvalidatableFile.hpp index e5008b5fb5..aa0f8c2c6b 100644 --- a/include/openPMD/IO/InvalidatableFile.hpp +++ b/include/openPMD/IO/InvalidatableFile.hpp @@ -93,7 +93,9 @@ struct less { using first_argument_type = openPMD::InvalidatableFile; using second_argument_type = first_argument_type; - using result_type = typename std::less::result_type; + using result_type = decltype(std::less<>()( + *std::declval(), + *std::declval())); result_type operator()(first_argument_type const &, second_argument_type const &) const; }; diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index c1cc2c0c12..3fe3d634fd 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include namespace openPMD::auxiliary::detail @@ -69,6 +70,15 @@ class DeferredComputation */ DeferredComputation(cached_type val); + explicit DeferredComputation(); + + DeferredComputation(DeferredComputation &&) noexcept; + DeferredComputation(DeferredComputation const &) = delete; + + auto operator=(DeferredComputation &&) noexcept -> DeferredComputation &; + auto operator=(DeferredComputation const &) + -> DeferredComputation & = delete; + ~DeferredComputation(); /** Get the result of the computation diff --git a/src/IO/AbstractIOHandler.cpp b/src/IO/AbstractIOHandler.cpp index 0614f26292..e54336a6c6 100644 --- a/src/IO/AbstractIOHandler.cpp +++ b/src/IO/AbstractIOHandler.cpp @@ -131,7 +131,11 @@ std::future AbstractIOHandler::flush(internal::ParsedFlushParams ¶ms) // been flushed already. bool increase_flush_counter = !m_work.empty(); auto res = this->flush_impl(params); - if (increase_flush_counter && m_work.empty()) + if (!m_work.empty()) + { + throw error::Internal("flush() did not clear all work!"); + } + if (increase_flush_counter) { ++*m_flushCounter; } diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 5607cf0589..c7b8a46507 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -53,6 +53,17 @@ DeferredComputation::DeferredComputation(cached_type cached_val) : m_task(detail::CachedValue{std::move(cached_val)}) {} +template +DeferredComputation::DeferredComputation() = default; + +template +DeferredComputation::DeferredComputation(DeferredComputation &&) noexcept = + default; + +template +auto DeferredComputation::operator=(DeferredComputation &&) noexcept + -> DeferredComputation & = default; + template DeferredComputation::~DeferredComputation() { From 3257d55677a923bf7657050c6fe07036b938d8bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Mon, 20 Apr 2026 18:48:40 +0200 Subject: [PATCH 44/47] Rename forget() -> invalidate() --- include/openPMD/auxiliary/Future.hpp | 2 +- src/auxiliary/Future.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index 3fe3d634fd..de58871544 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -95,7 +95,7 @@ class DeferredComputation /** Discard the computation without executing it */ - void forget() &&; + void invalidate() &&; /** Check if the computation is valid * diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index c7b8a46507..04db003c92 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -119,7 +119,7 @@ auto DeferredComputation::operator()() -> T } template -void DeferredComputation::forget() && +void DeferredComputation::invalidate() && { std::visit( auxiliary::overloaded{ From db6528db76df554981a14f9072baf88764af6ee6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Tue, 21 Apr 2026 17:31:51 +0200 Subject: [PATCH 45/47] Fix MSVC compilation --- include/openPMD/auxiliary/Future.hpp | 10 ++++++++-- src/auxiliary/Future.cpp | 8 ++++---- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index de58871544..095a64c1af 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -59,6 +59,11 @@ class DeferredComputation std::variant, detail::CachedValue> m_task; public: + static constexpr bool noexcept_move = + std::is_move_constructible_v> && + std::is_move_assignable_v> && + std::is_move_constructible_v> && + std::is_move_assignable_v>; /** Construct from a callable * * @param task The callable to execute @@ -72,10 +77,11 @@ class DeferredComputation explicit DeferredComputation(); - DeferredComputation(DeferredComputation &&) noexcept; + DeferredComputation(DeferredComputation &&) noexcept(noexcept_move); DeferredComputation(DeferredComputation const &) = delete; - auto operator=(DeferredComputation &&) noexcept -> DeferredComputation &; + auto operator=(DeferredComputation &&) noexcept(noexcept_move) + -> DeferredComputation &; auto operator=(DeferredComputation const &) -> DeferredComputation & = delete; diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 04db003c92..2ef4a79cb1 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -57,12 +57,12 @@ template DeferredComputation::DeferredComputation() = default; template -DeferredComputation::DeferredComputation(DeferredComputation &&) noexcept = - default; +DeferredComputation::DeferredComputation(DeferredComputation &&) noexcept( + noexcept_move) = default; template -auto DeferredComputation::operator=(DeferredComputation &&) noexcept - -> DeferredComputation & = default; +auto DeferredComputation::operator=(DeferredComputation &&) noexcept( + noexcept_move) -> DeferredComputation & = default; template DeferredComputation::~DeferredComputation() From cc348838049dc9516ea85b2782ea3a5f5d6dbd45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Wed, 22 Apr 2026 11:18:55 +0200 Subject: [PATCH 46/47] Fix move constructor / assignment operator --- include/openPMD/auxiliary/Future.hpp | 23 ++++++++++++-- src/auxiliary/Future.cpp | 45 +++++++++++++++++++++------- 2 files changed, 55 insertions(+), 13 deletions(-) diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index 095a64c1af..381f56c309 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -11,8 +11,27 @@ template struct OneTimeTask { using task_type = std::function; - task_type m_task; - bool m_task_valid = true; + // Helper struct so we get auto-generated move constructor / assignment + // operator, but can still override constructors outside + struct Members + { + task_type m_task; + bool m_task_valid = true; + }; + Members members; + + static constexpr bool noexcept_move = + std::is_move_constructible_v && + std::is_move_assignable_v; + + explicit OneTimeTask(); + OneTimeTask(task_type); + + OneTimeTask(OneTimeTask &&) noexcept(noexcept_move); + OneTimeTask(OneTimeTask const &) = delete; + + auto operator=(OneTimeTask &&) noexcept(noexcept_move) -> OneTimeTask &; + auto operator=(OneTimeTask const &) -> OneTimeTask & = delete; auto operator()() -> T; }; diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 2ef4a79cb1..12b62719b2 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -11,30 +11,53 @@ namespace openPMD::auxiliary::detail { +template +OneTimeTask::OneTimeTask() = default; + +template +OneTimeTask::OneTimeTask(task_type task) : members{std::move(task)} +{} + +template +OneTimeTask::OneTimeTask(OneTimeTask &&other) noexcept(noexcept_move) + : members(std::move(other.members)) +{ + other.members.m_task_valid = false; +} + +template +auto OneTimeTask::operator=(OneTimeTask &&other) noexcept(noexcept_move) + -> OneTimeTask & +{ + this->members = std::move(other.members); + other.members.m_task_valid = false; + return *this; +} + template auto OneTimeTask::operator()() -> T { - if (!this->m_task_valid) + if (!members.m_task_valid) { throw std::runtime_error( "[DeferredComputation] No valid state. Probably already " "computed."); } - if (!this->m_task) + if (!members.m_task) { throw std::runtime_error( "[DeferredComputation] No valid task was specified."); } - this->m_task_valid = false; + members.m_task_valid = false; if constexpr (std::is_void_v) { - std::move(this->m_task)(); - this->m_task = {}; + std::move(members.m_task)(); + members.m_task = {}; } else { - auto res = std::move(this->m_task)(); - this->m_task = {}; // reset + auto res = std::move(members.m_task)(); + members.m_task = {}; // reset return res; } } @@ -72,7 +95,7 @@ DeferredComputation::~DeferredComputation() std::visit( auxiliary::overloaded{ [](detail::OneTimeTask &task) { - if (task.m_task_valid) + if (task.members.m_task_valid) { std::move(task)(); } @@ -124,8 +147,8 @@ void DeferredComputation::invalidate() && std::visit( auxiliary::overloaded{ [](detail::OneTimeTask &task) { - task.m_task = {}; - task.m_task_valid = false; + task.members.m_task = {}; + task.members.m_task_valid = false; }, [](detail::CachedValue const &) {}}, this->m_task); @@ -137,7 +160,7 @@ auto DeferredComputation::valid() const noexcept -> bool return std::visit( auxiliary::overloaded{ [](detail::OneTimeTask const &task) { - return task.m_task_valid; + return task.members.m_task_valid; }, [](detail::CachedValue const &) { return true; }}, this->m_task); From 33676af8ad42c14d0ebcb79358d2677a572a2e77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20P=C3=B6schel?= Date: Wed, 22 Apr 2026 11:55:22 +0200 Subject: [PATCH 47/47] Add a small test for DeferredComputation --- include/openPMD/auxiliary/Future.hpp | 2 +- src/auxiliary/Future.cpp | 6 ++++-- test/AuxiliaryTest.cpp | 30 ++++++++++++++++++++++++++++ 3 files changed, 35 insertions(+), 3 deletions(-) diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp index 381f56c309..e4e51dc7eb 100644 --- a/include/openPMD/auxiliary/Future.hpp +++ b/include/openPMD/auxiliary/Future.hpp @@ -124,7 +124,7 @@ class DeferredComputation /** Check if the computation is valid * - * @return true if the computation has not been forgotten + * @return true if the computation has not been invalidated */ [[nodiscard]] auto valid() const noexcept -> bool; }; diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp index 12b62719b2..39af555f9e 100644 --- a/src/auxiliary/Future.cpp +++ b/src/auxiliary/Future.cpp @@ -1,4 +1,5 @@ #include "openPMD/auxiliary/Future.hpp" +#include "openPMD/Error.hpp" #include "openPMD/RecordComponent.hpp" #include @@ -39,13 +40,13 @@ auto OneTimeTask::operator()() -> T { if (!members.m_task_valid) { - throw std::runtime_error( + throw error::WrongAPIUsage( "[DeferredComputation] No valid state. Probably already " "computed."); } if (!members.m_task) { - throw std::runtime_error( + throw error::WrongAPIUsage( "[DeferredComputation] No valid task was specified."); } members.m_task_valid = false; @@ -168,6 +169,7 @@ auto DeferredComputation::valid() const noexcept -> bool template class DeferredComputation; template class DeferredComputation; +template class DeferredComputation; // used in tests // need this for clang-tidy #define OPENPMD_ARRAY(type) type[] diff --git a/test/AuxiliaryTest.cpp b/test/AuxiliaryTest.cpp index ee0b029473..3612b13adb 100644 --- a/test/AuxiliaryTest.cpp +++ b/test/AuxiliaryTest.cpp @@ -19,6 +19,8 @@ * If not, see . */ // expose private and protected members for invasive testing +#include "openPMD/Error.hpp" +#include "openPMD/auxiliary/Future.hpp" #if openPMD_USE_INVASIVE_TESTS #define OPENPMD_private public: #define OPENPMD_protected public: @@ -538,3 +540,31 @@ TEST_CASE("filesystem_test", "[auxiliary]") REQUIRE(!remove_file("./nonexistent_file_in_cmake_bin_directory")); #endif } + +TEST_CASE("future_test", "[auxiliary]") +{ + using task_type = auxiliary::DeferredComputation; + size_t counter = 0; + + auto make_task = [&counter]() { + counter = 0; + return task_type{[&counter]() { + ++counter; + return "success"; + }}; + }; + + auto move_construct = make_task(); + task_type move_constructed(std::move(move_construct)); + REQUIRE(counter == 0); + REQUIRE(move_constructed() == "success"); + REQUIRE(counter == 1); + REQUIRE_THROWS_AS(move_constructed(), error::WrongAPIUsage); + + auto move_assign = make_task(); + task_type move_assigned = std::move(move_assign); + REQUIRE(counter == 0); + REQUIRE(move_assigned() == "success"); + REQUIRE(counter == 1); + REQUIRE_THROWS_AS(move_assigned(), error::WrongAPIUsage); +}