diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml index cec28ffbc5..69bea2696a 100644 --- a/.github/workflows/linux.yml +++ b/.github/workflows/linux.yml @@ -291,6 +291,7 @@ jobs: -DopenPMD_USE_INVASIVE_TESTS=ON \ -DCMAKE_BUILD_TYPE=Debug cmake --build build --parallel 4 + export OPENPMD_FLUSH_IMMEDIATELY=0 ctest --test-dir build --output-on-failure cd share/openPMD/json_schema @@ -308,6 +309,9 @@ jobs: ./check.py "$i" done + export OPENPMD_FLUSH_IMMEDIATELY=1 + ctest --test-dir build --output-on-failure + musllinux_py10: runs-on: ubuntu-24.04 if: github.event.pull_request.draft == false diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml index 8ee5019bc0..d30d1c3b62 100644 --- a/.github/workflows/macos.yml +++ b/.github/workflows/macos.yml @@ -42,6 +42,10 @@ jobs: -DopenPMD_USE_ADIOS2=ON \ -DopenPMD_USE_INVASIVE_TESTS=ON cmake --build build --parallel 3 + export OPENPMD_FLUSH_IMMEDIATELY=0 + ctest --test-dir build --verbose + + export OPENPMD_FLUSH_IMMEDIATELY=1 ctest --test-dir build --verbose appleclang15_py: diff --git a/CMakeLists.txt b/CMakeLists.txt index 21ac656880..78eaf53e4c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -408,6 +408,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 @@ -419,6 +420,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/docs/source/details/backendconfig.rst b/docs/source/details/backendconfig.rst index 2f64366326..555b96f9c1 100644 --- a/docs/source/details/backendconfig.rst +++ b/docs/source/details/backendconfig.rst @@ -88,6 +88,9 @@ The key ``defer_iteration_parsing`` can be used to optimize the process of openi By default, a Series is parsed eagerly, i.e. opening a Series implies reading all available iterations. Especially when a Series has many iterations, this can be a costly operation and users may wish to defer parsing of iterations to a later point adding ``{"defer_iteration_parsing": true}`` to their JSON/TOML configuration. +The openPMD-api can be configured to treat load/store operations as *deferred* or as *immediate*, using either the boolean JSON option ``{"flush_immediately": true}`` or the environment variable ``OPENPMD_FLUSH_IMMEDIATELY=1``. +Load/store operations are deferred by default in the C++ API and immediate by default in the Python API. + When parsing non-eagerly, each iteration needs to be explicitly opened with ``Iteration::open()`` before accessing. (Notice that ``Iteration::open()`` is generally recommended to be used in parallel contexts to avoid parallel file accessing hazards). Using the Streaming API (i.e. ``SeriesInterface::readIteration()``) will do this automatically. diff --git a/docs/source/usage/workflow.rst b/docs/source/usage/workflow.rst index 8f79b3108e..2fb2f4a74a 100644 --- a/docs/source/usage/workflow.rst +++ b/docs/source/usage/workflow.rst @@ -109,7 +109,7 @@ The openPMD-api distinguishes between a number of different access modes: Deferred Data API Contract -------------------------- -IO operations are in general not performed by the openPMD API immediately after calling the corresponding API function. +In the C++ API, IO operations are by default not performed by the openPMD API immediately after calling the corresponding API function. Rather, operations are enqueued internally and performed at so-called *flush points*. A flush point is a point within an application's sequential control flow where the openPMD API must uphold the following guarantees: @@ -120,6 +120,11 @@ A flush point is a point within an application's sequential control flow where t In short: operations requested by ``storeChunk()`` and ``loadChunk()`` must happen exactly at flush points. +The openPMD-api may be configured to flush immediately upon calling a load/store operation, using either the JSON key ``{"flush_immediately": true}`` or the environment variable ``OPENPMD_FLUSH_IMMEDIATELY=1``, in order to introduce implicit flush points at each such method call. +Refer also to the :ref:`documentation page ` on JSON/TOML configuration. +This mode helps avoiding typical pitfalls in a deferred load/store API for performance-noncritical operations. +Immediate flushing is the default in the Python API. + Flush points are triggered by: * Calling ``Series::flush()``. diff --git a/include/openPMD/Dataset.hpp b/include/openPMD/Dataset.hpp index e1f0058885..b8af286e14 100644 --- a/include/openPMD/Dataset.hpp +++ b/include/openPMD/Dataset.hpp @@ -34,6 +34,18 @@ 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; + Extent extent; +}; + class Dataset { friend class RecordComponent; diff --git a/include/openPMD/Datatype.hpp b/include/openPMD/Datatype.hpp index 17cf6b67f4..3f667ae47f 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,15 +763,34 @@ 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); - -std::ostream &operator<<(std::ostream &, openPMD::Datatype const &); +/** Stream operator for Datatype + * + * @param os Output stream + * @param dt Datatype to output + * @return Reference to the stream + */ +std::ostream &operator<<(std::ostream &os, openPMD::Datatype const &dt); template constexpr auto datatypeIndex() -> size_t diff --git a/include/openPMD/Datatype.tpp b/include/openPMD/Datatype.tpp index e35f2e26b6..b09351fd77 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 @@ -285,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 diff --git a/include/openPMD/IO/ADIOS/ADIOS2File.hpp b/include/openPMD/IO/ADIOS/ADIOS2File.hpp index d34cc8ebe5..66aa47e702 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" @@ -107,11 +108,14 @@ 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/ADIOS2IOHandler.hpp b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp index 4316f5181f..e20c256a67 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" @@ -30,6 +31,7 @@ #include "openPMD/IO/AbstractIOHandler.hpp" #include "openPMD/IO/AbstractIOHandlerImpl.hpp" #include "openPMD/IO/AbstractIOHandlerImplCommon.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/FlushParametersInternal.hpp" #include "openPMD/IO/IOTask.hpp" #include "openPMD/IO/InvalidatableFile.hpp" @@ -509,6 +511,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 +625,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 +644,7 @@ class ADIOS2IOHandlerImpl { bool noGroupBased = false; bool blosc2bp5 = false; + bool memorySelection = false; } printedWarningsAlready; }; // ADIOS2IOHandlerImpl @@ -942,7 +958,7 @@ class ADIOS2IOHandler : public AbstractIOHandler try { auto params = internal::defaultParsedFlushParams; - this->flush(params); + this->flush_impl(params); } catch (std::exception const &ex) { @@ -962,9 +978,7 @@ class ADIOS2IOHandler : public AbstractIOHandler #if openPMD_HAVE_MPI ADIOS2IOHandler( - std::optional> initialize_from, - std::string path, - Access, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm, json::TracingJSON options, std::string engineType, @@ -973,9 +987,7 @@ class ADIOS2IOHandler : public AbstractIOHandler #endif ADIOS2IOHandler( - std::optional> initialize_from, - std::string path, - Access, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON options, std::string engineType, std::string specifiedExtension); @@ -990,6 +1002,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/ADIOS/macros.hpp b/include/openPMD/IO/ADIOS/macros.hpp index 8195d36e8a..2f09b47636 100644 --- a/include/openPMD/IO/ADIOS/macros.hpp +++ b/include/openPMD/IO/ADIOS/macros.hpp @@ -46,6 +46,34 @@ #define openPMD_HAVE_ADIOS2_BP5 0 #endif +namespace openPMD +{ +namespace detail +{ + /** Trait to check if a variable supports SetMemorySelection + * + * @tparam Variable ADIOS2 variable type + */ + template + struct CanTheMemorySelectionBeReset + { + static constexpr bool value = false; + }; + + template + struct CanTheMemorySelectionBeReset< + Variable, + decltype(std::declval().SetMemorySelection())> + { + static constexpr bool value = true; + }; +} // namespace detail + +/** Whether ADIOS2 Variable supports SetMemorySelection */ +constexpr bool CanTheMemorySelectionBeReset = + detail::CanTheMemorySelectionBeReset>::value; +} // namespace openPMD + #else #define openPMD_HAS_ADIOS_2_8 0 diff --git a/include/openPMD/IO/AbstractIOHandler.hpp b/include/openPMD/IO/AbstractIOHandler.hpp index 9b7735b5ba..43e3db2096 100644 --- a/include/openPMD/IO/AbstractIOHandler.hpp +++ b/include/openPMD/IO/AbstractIOHandler.hpp @@ -59,6 +59,11 @@ enum class FlushLevel * This mode defines a flush point (see docs/source/usage/workflow.rst.rst). */ UserFlush, + /** + * Flush triggered by storeChunk in immediate flush mode. + * Must not perform operations enqueued in m_chunks. + */ + ImmediateFlush, /** * Default mode, used when flushes are triggered internally, e.g. during * parsing to read attributes. Does not trigger a flush point. @@ -81,6 +86,66 @@ enum class FlushLevel CreateOrOpenFiles }; +namespace flush_level +{ + inline constexpr auto global_flushpoint(FlushLevel fl) + { + switch (fl) + { + case FlushLevel::UserFlush: + return true; + case FlushLevel::ImmediateFlush: + case FlushLevel::InternalFlush: + case FlushLevel::SkeletonOnly: + case FlushLevel::CreateOrOpenFiles: + return false; + } + return false; // unreachable + } + inline constexpr auto write_datasets(FlushLevel fl) + { + switch (fl) + { + case FlushLevel::UserFlush: + case FlushLevel::ImmediateFlush: + return true; + case FlushLevel::InternalFlush: + case FlushLevel::SkeletonOnly: + case FlushLevel::CreateOrOpenFiles: + return false; + } + return false; // unreachable + } + inline constexpr auto write_attributes(FlushLevel fl) + { + switch (fl) + { + case FlushLevel::UserFlush: + case FlushLevel::ImmediateFlush: + case FlushLevel::InternalFlush: + return true; + case FlushLevel::SkeletonOnly: + case FlushLevel::CreateOrOpenFiles: + return false; + } + return false; // unreachable + } + inline constexpr auto flush_hierarchy(FlushLevel fl) + { + switch (fl) + { + case FlushLevel::UserFlush: + case FlushLevel::ImmediateFlush: + case FlushLevel::InternalFlush: + case FlushLevel::SkeletonOnly: + return true; + case FlushLevel::CreateOrOpenFiles: + return false; + } + return false; // unreachable + } +} // namespace flush_level + enum class OpenpmdStandard { v_1_0_0, @@ -187,12 +252,64 @@ namespace internal return res; } } + + /************************************************************************** + * Since the AbstractIOHandler is linked to every object of the + * frontend, it stores a number of members that are needed by methods + * traversing the object hierarchy. Those members are found in this struct + * from which AbstractIOHandler derives. + **************************************************************************/ + struct GlobalParameters + { + GlobalParameters(Access at); + + std::string directory; + /* + * Originally, the reason for distinguishing these two was that during + * parsing in reading access modes, the access type would be temporarily + * const_cast'ed to an access type that would support modifying + * the openPMD object model. Then, it would be const_cast'ed back to + * READ_ONLY, to disable further modifications. + * Due to this approach's tendency to cause subtle bugs, and due to its + * difficult debugging properties, this was replaced by the SeriesStatus + * enum, defined in this file. + * The distinction of backendAccess and frontendAccess stays relevant, + * since the frontend can use it in order to pretend to the backend that + * another access type is being used. This is used by the file-based + * append mode, which is entirely implemented by the frontend, which + * internally uses the backend in CREATE mode. + */ + Access m_backendAccess; + Access m_frontendAccess; + + /** + * This is to avoid that the destructor tries flushing again if an error + * happened. Otherwise, this would lead to confusing error messages. + * Initialized as false, set to true after successful construction. + * If flushing results in an error, set this back to false. + * The destructor will only attempt flushing again if this is true. + */ + bool m_lastFlushSuccessful = false; + internal::SeriesStatus m_seriesStatus = internal::SeriesStatus::Default; + IterationEncoding m_encoding = IterationEncoding::groupBased; + OpenpmdStandard m_standard = + auxiliary::parseStandard(getStandardDefault()); + bool m_verify_homogeneous_extents = true; + // If true, then flush directly upon storeChunk + bool m_flush_immediately = false; + + protected: + explicit GlobalParameters(); + }; } // namespace internal namespace detail { class ADIOS2File; -} + struct InitFrom_Tag + {}; + constexpr InitFrom_Tag InitFrom_Tag_v; +} // namespace detail /** Interface for communicating between logical and physically persistent data. * @@ -202,7 +319,7 @@ namespace detail * scenarios it is therefore necessary to manually execute all operations * by calling AbstractIOHandler::flush(). */ -class AbstractIOHandler +class AbstractIOHandler : public internal::GlobalParameters { friend class Series; friend class ADIOS2IOHandlerImpl; @@ -221,23 +338,16 @@ class AbstractIOHandler public: #if openPMD_HAVE_MPI - template + template AbstractIOHandler( - std::optional> initialize_from, - std::string path, - Access at, - TracingJSON &&jsonConfig, - MPI_Comm); + InitFrom &&initialize_from, TracingJSON &&jsonConfig, MPI_Comm); #endif - template - AbstractIOHandler( - std::optional> initialize_from, - std::string path, - Access at, - TracingJSON &&jsonConfig); + template + AbstractIOHandler(InitFrom &&initialize_from, TracingJSON &&jsonConfig); - AbstractIOHandler(std::optional>); + template + AbstractIOHandler(detail::InitFrom_Tag, InitFrom &&); virtual ~AbstractIOHandler(); @@ -265,56 +375,37 @@ class AbstractIOHandler * backends that decide to implement this operation asynchronously. */ std::future flush(internal::FlushParams const &); + std::queue m_work; + /** 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); /** 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; virtual bool fullSupportForVariableBasedEncoding() const; - std::string directory; - /* - * Originally, the reason for distinguishing these two was that during - * parsing in reading access modes, the access type would be temporarily - * const_cast'ed to an access type that would support modifying - * the openPMD object model. Then, it would be const_cast'ed back to - * READ_ONLY, to disable further modifications. - * Due to this approach's tendency to cause subtle bugs, and due to its - * difficult debugging properties, this was replaced by the SeriesStatus - * enum, defined in this file. - * The distinction of backendAccess and frontendAccess stays relevant, since - * the frontend can use it in order to pretend to the backend that another - * access type is being used. This is used by the file-based append mode, - * which is entirely implemented by the frontend, which internally uses - * the backend in CREATE mode. - */ - Access m_backendAccess; - Access m_frontendAccess; - std::queue m_work; - - /************************************************************************** - * Since the AbstractIOHandler is linked to every object of the frontend, * - * it stores a number of members that are needed by methods traversing * - * the object hierarchy. Those members are found below. * - **************************************************************************/ - - /** - * This is to avoid that the destructor tries flushing again if an error - * happened. Otherwise, this would lead to confusing error messages. - * Initialized as false, set to true after successful construction. - * If flushing results in an error, set this back to false. - * The destructor will only attempt flushing again if this is 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 */ - bool m_lastFlushSuccessful = false; - internal::SeriesStatus m_seriesStatus = internal::SeriesStatus::Default; - IterationEncoding m_encoding = IterationEncoding::groupBased; - OpenpmdStandard m_standard = auxiliary::parseStandard(getStandardDefault()); - bool m_verify_homogeneous_extents = true; + virtual std::future + flush_impl(internal::ParsedFlushParams ¶ms) = 0; }; // AbstractIOHandler } // namespace openPMD diff --git a/include/openPMD/IO/AbstractIOHandlerHelper.hpp b/include/openPMD/IO/AbstractIOHandlerHelper.hpp index d86911ad35..c50f2c82d1 100644 --- a/include/openPMD/IO/AbstractIOHandlerHelper.hpp +++ b/include/openPMD/IO/AbstractIOHandlerHelper.hpp @@ -33,10 +33,6 @@ namespace openPMD * @param initialize_from Optionally initialize the IOHandler from a previous * interim IOHandler which to replace with the handler now * being initialized. - * @param path Path to root folder for all operations associated with - the desired handler. - * @param access Access mode describing desired operations and - permissions of the desired handler. * @param format Format describing the IO backend of the desired handler. * @param originalExtension The filename extension as it was originally * specified by the user. @@ -48,11 +44,9 @@ namespace openPMD including nlohmann::json in a .hpp file. * @return Smart pointer to created IOHandler. */ -template +template std::unique_ptr createIOHandler( - std::optional> initialize_from, - std::string path, - Access access, + Init_t &&initialize_from, Format format, std::string originalExtension, MPI_Comm comm, @@ -65,10 +59,6 @@ std::unique_ptr createIOHandler( * @param initialize_from Optionally initialize the IOHandler from a previous * interim IOHandler which to replace with the handler now * being initialized. - * @param path Path to root folder for all operations associated with - * the desired handler. - * @param access Access describing desired operations and permissions - * of the desired handler. * @param format Format describing the IO backend of the desired handler. * @param originalExtension The filename extension as it was originally * specified by the user. @@ -79,21 +69,16 @@ std::unique_ptr createIOHandler( including nlohmann::json in a .hpp file. * @return Smart pointer to created IOHandler. */ -template +template std::unique_ptr createIOHandler( - std::optional> initialize_from, - std::string path, - Access access, + Init_t &&initialize_from, Format format, std::string originalExtension, JSON options, std::string const &pathAsItWasSpecifiedInTheConstructor); // version without configuration to use in AuxiliaryTest +template std::unique_ptr createIOHandler( - std::optional> initialize_from, - std::string path, - Access access, - Format format, - std::string originalExtension); + Init_t &&initialize_from, Format format, std::string originalExtension); } // namespace openPMD diff --git a/include/openPMD/IO/AbstractIOHandler_internal.hpp b/include/openPMD/IO/AbstractIOHandler_internal.hpp new file mode 100644 index 0000000000..7caa2f3b6f --- /dev/null +++ b/include/openPMD/IO/AbstractIOHandler_internal.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include "openPMD/IO/AbstractIOHandler.hpp" + +#include + +namespace openPMD::internal +{ +struct AbstractIOHandlerInitFrom + : std::variant +{ + using Left = GlobalParameters; + using Right = AbstractIOHandler *; + using parent_t = std::variant; + using parent_t::parent_t; + inline auto as_parent() -> parent_t & + { + return *this; + } + [[nodiscard]] inline auto as_parent() const -> parent_t const & + { + return *this; + } + auto asGlobalParameters() -> GlobalParameters &; + [[nodiscard]] auto asGlobalParameters() const -> GlobalParameters const &; +}; +} // namespace openPMD::internal diff --git a/include/openPMD/IO/DummyIOHandler.hpp b/include/openPMD/IO/DummyIOHandler.hpp index 8abcf20990..dfc91215e5 100644 --- a/include/openPMD/IO/DummyIOHandler.hpp +++ b/include/openPMD/IO/DummyIOHandler.hpp @@ -21,6 +21,7 @@ #pragma once #include "openPMD/IO/AbstractIOHandler.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/Access.hpp" #include "openPMD/IO/IOTask.hpp" @@ -34,7 +35,7 @@ namespace openPMD class DummyIOHandler : public AbstractIOHandler { public: - DummyIOHandler(std::string, Access); + DummyIOHandler(internal::AbstractIOHandlerInitFrom &&); ~DummyIOHandler() override = default; /** No-op consistent with the IOHandler interface to enable library use @@ -44,7 +45,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..ba8daaa048 100644 --- a/include/openPMD/IO/HDF5/HDF5IOHandler.hpp +++ b/include/openPMD/IO/HDF5/HDF5IOHandler.hpp @@ -21,6 +21,7 @@ #pragma once #include "openPMD/IO/AbstractIOHandler.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/auxiliary/JSON_internal.hpp" #include @@ -35,9 +36,7 @@ class HDF5IOHandler : public AbstractIOHandler { public: HDF5IOHandler( - std::optional> initialize_from, - std::string path, - Access, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON config); ~HDF5IOHandler() override; @@ -46,7 +45,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..d8a69d479e 100644 --- a/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp +++ b/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp @@ -21,6 +21,7 @@ #pragma once #include "openPMD/IO/AbstractIOHandler.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/auxiliary/JSON_internal.hpp" #include "openPMD/config.hpp" @@ -37,16 +38,12 @@ class ParallelHDF5IOHandler : public AbstractIOHandler public: #if openPMD_HAVE_MPI ParallelHDF5IOHandler( - std::optional> initialize_from, - std::string path, - Access, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm, json::TracingJSON config); #else ParallelHDF5IOHandler( - std::optional> initialize_from, - std::string const &path, - Access, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON config); #endif ~ParallelHDF5IOHandler() override; @@ -56,7 +53,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/IOTask.hpp b/include/openPMD/IO/IOTask.hpp index 25e0d6ad54..662a34f9e3 100644 --- a/include/openPMD/IO/IOTask.hpp +++ b/include/openPMD/IO/IOTask.hpp @@ -495,6 +495,8 @@ 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; }; @@ -558,7 +560,9 @@ 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 be9d83ac6b..aa0f8c2c6b 100644 --- a/include/openPMD/IO/InvalidatableFile.hpp +++ b/include/openPMD/IO/InvalidatableFile.hpp @@ -83,12 +83,19 @@ 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 { using first_argument_type = openPMD::InvalidatableFile; using second_argument_type = first_argument_type; - using result_type = bool; + 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/IO/JSON/JSONIOHandler.hpp b/include/openPMD/IO/JSON/JSONIOHandler.hpp index 07e797d4b3..c0821a17fb 100644 --- a/include/openPMD/IO/JSON/JSONIOHandler.hpp +++ b/include/openPMD/IO/JSON/JSONIOHandler.hpp @@ -22,6 +22,7 @@ #pragma once #include "openPMD/IO/AbstractIOHandler.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/JSON/JSONIOHandlerImpl.hpp" #include "openPMD/auxiliary/JSON_internal.hpp" @@ -35,17 +36,13 @@ class JSONIOHandler : public AbstractIOHandler { public: JSONIOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, openPMD::json::TracingJSON config, JSONIOHandlerImpl::FileFormat, std::string originalExtension); #if openPMD_HAVE_MPI JSONIOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm, openPMD::json::TracingJSON config, JSONIOHandlerImpl::FileFormat, @@ -59,7 +56,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/Iteration.hpp b/include/openPMD/Iteration.hpp index 0892627f2d..d63590bfe9 100644 --- a/include/openPMD/Iteration.hpp +++ b/include/openPMD/Iteration.hpp @@ -479,6 +479,12 @@ class Iteration 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 new file mode 100644 index 0000000000..89983ab0fe --- /dev/null +++ b/include/openPMD/LoadStoreChunk.hpp @@ -0,0 +1,402 @@ +#pragma once + +#include "openPMD/Dataset.hpp" +#include "openPMD/auxiliary/Future.hpp" +#include "openPMD/auxiliary/Memory.hpp" +#include "openPMD/auxiliary/UniquePtr.hpp" + +// comment to prevent this include from being moved by clang-format +#include "openPMD/DatatypeMacros.hpp" + +#include +#include + +namespace openPMD +{ +class RecordComponent; +class ConfigureStoreChunkFromBuffer; +class ConfigureLoadStoreFromBuffer; +template +class DynamicMemoryView; +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; + 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 + +/** 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 + * 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; + + bool m_unsafeNoAutomaticFlush = false; + + [[nodiscard]] auto dim() const -> uint8_t; + auto storeChunkConfig() -> internal::LoadStoreConfig; + + 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); + void unsafeNoAutomaticFlush_impl(); + +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; + + // 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; + } + + /* + * If the type is non-const, then the return type should be + * ConfigureLoadStoreFromBuffer, but if it is a const type, Load operations + * make no sense, so the return type should be + * ConfigureStoreChunkFromBuffer<>. + */ + template + 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; + + // Buffer specification methods (return specialized configurations) + 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>; + + // Enqueue methods (deferred execution) + template + [[nodiscard]] auto storeSpan() -> DynamicMemoryView; + // definition for this one is in RecordComponent.tpp since it needs the + // definition of class RecordComponent. + template + [[nodiscard]] auto storeSpan(F &&createBuffer) -> DynamicMemoryView; + + template + [[nodiscard]] auto load() + -> auxiliary::DeferredComputation>; + + [[nodiscard]] auto loadVariant() -> auxiliary::DeferredComputation< + 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; + +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. + + /** Set memory selection for non-contiguous memory regions */ + void memorySelection_impl(MemorySelection); + + auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer; + +public: + 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)); + return *this; + } + + // 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 + * 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 + auto load() + { + static_assert( + auxiliary::dependent_false_v, + "Cannot load chunk data into a buffer that is const or a " + "unique_ptr."); + } +}; + +/** 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; + friend class RecordComponent; + + using ConfigureStoreChunkFromBuffer::ConfigureStoreChunkFromBuffer; + +public: + 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)); + return *this; + } + + // Enqueue method (deferred execution) + + /** Load the chunk data into the buffer + * + * @return Deferred computation that performs the load when invoked + */ + auto load() -> auxiliary::DeferredComputation; +}; + +} // 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..f6b0fedf15 --- /dev/null +++ b/include/openPMD/LoadStoreChunk.tpp @@ -0,0 +1,76 @@ +#pragma once + +#include "openPMD/LoadStoreChunk.hpp" + +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< + 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 diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp index 1ec1ff8d9c..9fd2e53027 100644 --- a/include/openPMD/ParticleSpecies.hpp +++ b/include/openPMD/ParticleSpecies.hpp @@ -70,6 +70,11 @@ class ParticleSpecies 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 3def700f71..d9f9c3a080 100644 --- a/include/openPMD/RecordComponent.hpp +++ b/include/openPMD/RecordComponent.hpp @@ -22,6 +22,7 @@ #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" @@ -30,9 +31,6 @@ #include "openPMD/backend/HierarchyVisitor.hpp" #include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp" -// comment to prevent this include from being moved by clang-format -#include "openPMD/DatatypeMacros.hpp" - #include #include #include @@ -77,7 +75,8 @@ namespace internal */ std::queue m_chunks; - void push_chunk(IOTask &&task); + void push_chunk( + IOTask &&task, std::optional immediate_flush = std::nullopt); /** * Stores the value for constant record components. * Ignored otherwise. @@ -134,6 +133,12 @@ class RecordComponent friend T &internal::makeOwning(T &self, Series); friend class internal::ScientificDefaults; friend class Attributable; + friend class ConfigureLoadStore; + friend class ConfigureLoadStoreFromBuffer; + friend class ConfigureStoreChunkFromBuffer; + friend struct VisitorEnqueueLoadVariantWithoutFlush; + friend struct VisitorEnqueueLoadVariantWithFlush; + friend struct VisitorLoadVariant; public: enum class Allocation @@ -220,6 +225,16 @@ class RecordComponent */ 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 * * Set offset to {0u} and extent to {-1u} for full selection. @@ -230,11 +245,8 @@ class RecordComponent 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) * @@ -272,25 +284,6 @@ class RecordComponent 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 @@ -330,18 +323,6 @@ class RecordComponent 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 @@ -505,8 +486,29 @@ class RecordComponent */ RecordComponent &makeEmpty(Dataset d); - void storeChunk( - auxiliary::WriteBuffer buffer, Datatype datatype, Offset o, Extent e); + void storeChunk_impl( + auxiliary::WriteBuffer buffer, + Datatype datatype, + internal::LoadStoreConfigWithBuffer, + std::optional flush_immediately = std::nullopt); + + template + DynamicMemoryView storeChunkSpan_impl(internal::LoadStoreConfig); + template + DynamicMemoryView storeChunkSpanCreateBuffer_impl( + internal::LoadStoreConfig, F &&createBuffer); + + template + void loadChunk_impl( + std::shared_ptr const &, internal::LoadStoreConfigWithBuffer); + void loadChunk_impl( + std::shared_ptr const &, + Datatype, + 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 @@ -576,6 +578,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..1af4f8eab6 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,12 @@ 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)) + .unsafeNoAutomaticFlush() + .store(); } template @@ -50,39 +56,74 @@ 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) + .unsafeNoAutomaticFlush() + .store(); } template inline DynamicMemoryView RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer) { + return prepareLoadStore() + .offset(std::move(o)) + .extent(std::move(e)) + .storeSpan(std::forward(createBuffer)); +} + +namespace detail +{ + template + struct pointer_as_void; + + template + struct pointer_as_void> + { + static auto call(std::shared_ptr const &ptr) + -> std::shared_ptr + { + return std::static_pointer_cast(ptr); + } + }; + + template + struct pointer_as_void> + { + static auto call(std::unique_ptr &&ptr) -> UniquePtrWithLambda + { + return UniquePtrWithLambda(std::move(ptr)); + } + }; + template + struct pointer_as_void> + { + static auto call(std::unique_ptr &&ptr) + -> UniquePtrWithLambda + { + return UniquePtrWithLambda(std::move(ptr)) + .template static_cast_(); + } + }; +} // namespace detail + +template +inline DynamicMemoryView RecordComponent::storeChunkSpanCreateBuffer_impl( + internal::LoadStoreConfig cfg, F &&createBuffer) +{ + auto [o, e] = std::move(cfg); verifyChunk(o, e); size_t size = 1; @@ -151,8 +192,17 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer) getBufferView.out->ptr = static_cast(data.get()); if (size > 0) { - storeChunk(std::move(data), std::move(o), std::move(e)); + using ptr_type = decltype(data); + internal::LoadStoreConfigWithBuffer ls_cfg{ + std::move(o), std::move(e), std::nullopt}; + storeChunk_impl( + auxiliary::WriteBuffer( + detail::pointer_as_void::call(std::move(data))), + getBufferView.dtype, + std::move(ls_cfg), + /*flush_immediately=*/false); } + // storeChunk(std::move(data), std::move(o), std::move(e)); } setDirtyRecursive(true); return DynamicMemoryView{std::move(getBufferView), size, *this}; @@ -189,4 +239,12 @@ inline auto RecordComponent::visit(Args &&...args) return switchDatasetType>( getDatatype(), *this, std::forward(args)...); } + +// definitions for LoadStoreChunk.hpp +template +auto ConfigureLoadStore::storeSpan(F &&createBuffer) -> DynamicMemoryView +{ + return m_rc.storeChunkSpanCreateBuffer_impl( + storeChunkConfig(), std::forward(createBuffer)); +} } // namespace openPMD diff --git a/include/openPMD/Series.hpp b/include/openPMD/Series.hpp index 93dfe333b4..38acd94ebd 100644 --- a/include/openPMD/Series.hpp +++ b/include/openPMD/Series.hpp @@ -791,6 +791,8 @@ class Series : public Attributable "Cannot call this on an instance of Series."); } + [[nodiscard]] bool flushImmediately() const; + // clang-format off OPENPMD_private // clang-format on @@ -837,7 +839,7 @@ OPENPMD_private Attributable::setData(m_series); } - std::unique_ptr parseInput(std::string); + std::unique_ptr parseInput(std::string) const; /** * @brief Parse non-backend-specific configuration in JSON config. * @@ -848,7 +850,8 @@ OPENPMD_private * to include the JSON lib here */ template - void parseJsonOptions(TracingJSON &options, ParsedInput &); + void parseJsonOptions( + TracingJSON &options, ParsedInput &, internal::GlobalParameters &); bool hasExpansionPattern(std::string filenameWithExtension); bool reparseExpansionPattern(std::string filenameWithExtension); template @@ -858,10 +861,11 @@ OPENPMD_private std::string const &options, MPI_Communicator &&...); template - std::tuple, TracingJSON> initIOHandler( + std::tuple, TracingJSON> + prepareIOHandlerArguments( + internal::GlobalParameters &, std::string const &filepath, std::string const &options, - Access at, bool resolve_generic_extension, MPI_Communicator &&...); void initSeries( 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 new file mode 100644 index 0000000000..e4e51dc7eb --- /dev/null +++ b/include/openPMD/auxiliary/Future.hpp @@ -0,0 +1,131 @@ +#pragma once + +#include +#include +#include + +namespace openPMD::auxiliary::detail +{ +/** Internal helper for deferred computation - executes task once */ +template +struct OneTimeTask +{ + using task_type = std::function; + // 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; +}; + +/** 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 +{ + T val; +}; +template <> +struct CachedValue +{ + // this is silly +}; +} // namespace openPMD::auxiliary::detail + +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 +{ + using task_type = std::function; + 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: + 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 + */ + DeferredComputation(task_type task); + /** Construct from a cached value + * + * @param val The pre-computed value + */ + DeferredComputation(cached_type val); + + explicit DeferredComputation(); + + DeferredComputation(DeferredComputation &&) noexcept(noexcept_move); + DeferredComputation(DeferredComputation const &) = delete; + + auto operator=(DeferredComputation &&) noexcept(noexcept_move) + -> DeferredComputation &; + auto operator=(DeferredComputation const &) + -> DeferredComputation & = delete; + + ~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 invalidate() &&; + + /** Check if the computation is valid + * + * @return true if the computation has not been invalidated + */ + [[nodiscard]] auto valid() const noexcept -> bool; +}; +} // namespace openPMD::auxiliary diff --git a/include/openPMD/auxiliary/Memory.hpp b/include/openPMD/auxiliary/Memory.hpp index 6f8807b354..99b6b53d22 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,17 +74,21 @@ 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); - WriteBuffer const &operator=(UniquePtrWithLambda ptr); + // @todo implementation must distinguish const types + template + WriteBuffer &operator=(std::shared_ptr const &ptr); + WriteBuffer &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/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 diff --git a/include/openPMD/backend/Attributable.hpp b/include/openPMD/backend/Attributable.hpp index f05cc8d15b..944a162bea 100644 --- a/include/openPMD/backend/Attributable.hpp +++ b/include/openPMD/backend/Attributable.hpp @@ -249,6 +249,7 @@ class Attributable friend struct internal::HomogenizeExtents; friend struct internal::ConfigAttribute; friend class internal::ScientificDefaults; + friend class ConfigureLoadStore; protected: // tag for internal constructor @@ -606,6 +607,28 @@ OPENPMD_protected { return writable().dirtyRecursive; } + void determineUnsetDirty(FlushLevel fl) + { + switch (fl) + { + case FlushLevel::UserFlush: + setDirty(false); + break; + case FlushLevel::InternalFlush: + // Used for parsing + if (IOHandler()->m_seriesStatus == internal::SeriesStatus::Parsing) + { + throw error::Internal( + "Parsing procedures should directly unset dirty."); + } + break; + case FlushLevel::ImmediateFlush: + case FlushLevel::SkeletonOnly: + case FlushLevel::CreateOrOpenFiles: + // noop + break; + } + } void setDirty(bool dirty_in) { auto &w = writable(); 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; diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp index 1d181033eb..1dcac594fd 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) { @@ -98,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(); @@ -106,6 +116,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 +124,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 +147,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 +202,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"; @@ -1049,25 +1094,16 @@ void ADIOS2File::flush_impl( drainedUniquePtrPuts.swap(m_uniquePtrPuts); } - if (readOnly(m_mode)) - { - level = FlushLevel::UserFlush; - } - - switch (level) + if (readOnly(m_mode) || flush_level::write_datasets(level)) { - case FlushLevel::UserFlush: performPutGets(*this, eng); m_updateSpans.clear(); m_buffer.clear(); m_alreadyEnqueued.clear(); drainedUniquePtrPuts.clear(); - - break; - - case FlushLevel::InternalFlush: - case FlushLevel::SkeletonOnly: - case FlushLevel::CreateOrOpenFiles: + } + else + { /* * Tasks have been given to ADIOS2, but we don't flush them * yet. So, move everything to m_alreadyEnqueued to avoid @@ -1084,7 +1120,6 @@ void ADIOS2File::flush_impl( "wrong time."); } m_buffer.clear(); - break; } } diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp index 2e8084848d..defc5de7af 100644 --- a/src/IO/ADIOS/ADIOS2IOHandler.cpp +++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp @@ -30,6 +30,7 @@ #include "openPMD/IO/ADIOS/ADIOS2IOHandler.hpp" #include "openPMD/IO/ADIOS/ADIOS2PreloadAttributes.hpp" #include "openPMD/IO/ADIOS/ADIOS2PreloadVariables.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/IOTask.hpp" #include "openPMD/IterationEncoding.hpp" #include "openPMD/Streaming.hpp" @@ -51,6 +52,7 @@ #include #include #include +#include #include #include #include @@ -1247,6 +1249,7 @@ namespace detail adios2::Variable variable = impl->verifyDataset( params.offset, params.extent, + std::nullopt, IO, engine, varName, @@ -2612,38 +2615,28 @@ namespace detail #if openPMD_HAVE_MPI ADIOS2IOHandler::ADIOS2IOHandler( - std::optional> initialize_from, - std::string path, - openPMD::Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm comm, json::TracingJSON options, std::string engineType, std::string specifiedExtension) - : AbstractIOHandler( - std::move(initialize_from), - std::move(path), - at, - std::move(options), - comm) + : AbstractIOHandler(std::move(initialize_from), std::move(options), comm) , m_impl{this, comm, std::move(engineType), std::move(specifiedExtension)} {} #endif ADIOS2IOHandler::ADIOS2IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON options, std::string engineType, std::string specifiedExtension) - : AbstractIOHandler( - std::move(initialize_from), std::move(path), at, std::move(options)) + : AbstractIOHandler(std::move(initialize_from), std::move(options)) , m_impl{this, std::move(engineType), std::move(specifiedExtension)} {} std::future -ADIOS2IOHandler::flush(internal::ParsedFlushParams &flushParams) +ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &flushParams) { return m_impl.flush(flushParams); } @@ -2652,39 +2645,29 @@ ADIOS2IOHandler::flush(internal::ParsedFlushParams &flushParams) #if openPMD_HAVE_MPI ADIOS2IOHandler::ADIOS2IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm comm, json::TracingJSON config, // NOLINTNEXTLINE(performance-unnecessary-value-param) std::string, // NOLINTNEXTLINE(performance-unnecessary-value-param) std::string) - : AbstractIOHandler( - std::move(initialize_from), - std::move(path), - at, - std::move(config), - comm) + : AbstractIOHandler(std::move(initialize_from), std::move(config), comm) {} #endif // openPMD_HAVE_MPI ADIOS2IOHandler::ADIOS2IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON config, // NOLINTNEXTLINE(performance-unnecessary-value-param) std::string, // NOLINTNEXTLINE(performance-unnecessary-value-param) std::string) - : AbstractIOHandler( - std::move(initialize_from), std::move(path), at, std::move(config)) + : AbstractIOHandler(std::move(initialize_from), std::move(config)) {} -std::future ADIOS2IOHandler::flush(internal::ParsedFlushParams &) +std::future ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &) { return std::future(); } diff --git a/src/IO/AbstractIOHandler.cpp b/src/IO/AbstractIOHandler.cpp index 5f2bdeb2f5..d811f7e324 100644 --- a/src/IO/AbstractIOHandler.cpp +++ b/src/IO/AbstractIOHandler.cpp @@ -22,10 +22,12 @@ #include "openPMD/IO/AbstractIOHandler.hpp" #include "openPMD/Error.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/FlushParametersInternal.hpp" #include "openPMD/auxiliary/JSONMatcher.hpp" #include +#include namespace openPMD::auxiliary { @@ -63,6 +65,14 @@ auto formatStandard(OpenpmdStandard std) -> char const * } } // namespace openPMD::auxiliary +namespace openPMD::internal +{ +GlobalParameters::GlobalParameters(Access at) + : m_backendAccess(at), m_frontendAccess(at) +{} +GlobalParameters::GlobalParameters() = default; +} // namespace openPMD::internal + namespace openPMD { void AbstractIOHandler::setIterationEncoding(IterationEncoding encoding) @@ -122,49 +132,65 @@ 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 (!m_work.empty()) + { + throw error::Internal("flush() did not clear all work!"); + } + if (increase_flush_counter) + { + ++*m_flushCounter; + } + return res; +} + bool AbstractIOHandler::fullSupportForVariableBasedEncoding() const { return false; } +template <> +AbstractIOHandler::AbstractIOHandler( + detail::InitFrom_Tag, internal::AbstractIOHandlerInitFrom &&initialize_from) +{ + using IF = internal::AbstractIOHandlerInitFrom; + std::visit( + auxiliary::overloaded{ + [this](IF::Left &&l) { + static_cast(this)->operator=( + std::move(l)); + }, + [this](IF::Right &&r) { this->operator=(std::move(*r)); }}, + std::move(initialize_from.as_parent())); +} + #if openPMD_HAVE_MPI template <> AbstractIOHandler::AbstractIOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON &&jsonConfig, MPI_Comm) - : AbstractIOHandler(std::move(initialize_from)) + : AbstractIOHandler(detail::InitFrom_Tag_v, std::move(initialize_from)) { jsonMatcher = std::make_unique(std::move(jsonConfig)); - directory = std::move(path); - m_backendAccess = at; - m_frontendAccess = at; } #endif template <> AbstractIOHandler::AbstractIOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON &&jsonConfig) - : AbstractIOHandler(std::move(initialize_from)) + : AbstractIOHandler(detail::InitFrom_Tag_v, std::move(initialize_from)) { jsonMatcher = std::make_unique(std::move(jsonConfig)); - directory = std::move(path); - m_backendAccess = at; - m_frontendAccess = at; -} - -AbstractIOHandler::AbstractIOHandler( - std::optional> initialize_from) -{ - if (initialize_from.has_value() && *initialize_from) - { - this->operator=(std::move(**initialize_from)); - } } AbstractIOHandler::~AbstractIOHandler() = default; @@ -175,3 +201,29 @@ AbstractIOHandler::AbstractIOHandler(AbstractIOHandler &&) = default; AbstractIOHandler & AbstractIOHandler::operator=(AbstractIOHandler &&) noexcept = default; } // namespace openPMD + +namespace openPMD::internal +{ +auto AbstractIOHandlerInitFrom::asGlobalParameters() const + -> GlobalParameters const & +{ + return std::visit( + auxiliary::overloaded{ + [](Left const ¶ms) -> GlobalParameters const & { + // ?? why + // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter) + return params; + }, + [](Right const &ioHandler) -> GlobalParameters const & { + return *ioHandler; + }}, + this->as_parent()); +} + +auto AbstractIOHandlerInitFrom::asGlobalParameters() -> GlobalParameters & +{ + return const_cast( + static_cast(this) + ->asGlobalParameters()); +} +} // namespace openPMD::internal diff --git a/src/IO/AbstractIOHandlerHelper.cpp b/src/IO/AbstractIOHandlerHelper.cpp index 443d22f498..f1855738bf 100644 --- a/src/IO/AbstractIOHandlerHelper.cpp +++ b/src/IO/AbstractIOHandlerHelper.cpp @@ -20,6 +20,7 @@ */ #include "openPMD/IO/AbstractIOHandlerHelper.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/config.hpp" #include "openPMD/Error.hpp" @@ -64,10 +65,9 @@ namespace #if openPMD_HAVE_MPI template <> -std::unique_ptr createIOHandler( - std::optional> initialize_from, - std::string path, - Access access, +std::unique_ptr +createIOHandler( + internal::AbstractIOHandlerInitFrom &&initialize_from, Format format, std::string originalExtension, MPI_Comm comm, @@ -79,18 +79,11 @@ std::unique_ptr createIOHandler( { case Format::HDF5: return constructIOHandler( - "HDF5", - std::move(initialize_from), - std::move(path), - access, - comm, - std::move(options)); + "HDF5", std::move(initialize_from), comm, std::move(options)); case Format::ADIOS2_BP: return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), "file", @@ -99,8 +92,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), "bp4", @@ -109,8 +100,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), "bp5", @@ -119,8 +108,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), "sst", @@ -129,8 +116,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), "ssc", @@ -139,8 +124,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "JSON", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), JSONIOHandlerImpl::FileFormat::Json, @@ -149,8 +132,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "JSON", std::move(initialize_from), - std::move(path), - access, comm, std::move(options), JSONIOHandlerImpl::FileFormat::Toml, @@ -165,10 +146,9 @@ std::unique_ptr createIOHandler( #endif template <> -std::unique_ptr createIOHandler( - std::optional> initialize_from, - std::string path, - Access access, +std::unique_ptr +createIOHandler( + internal::AbstractIOHandlerInitFrom &&initialize_from, Format format, std::string originalExtension, json::TracingJSON options, @@ -179,17 +159,11 @@ std::unique_ptr createIOHandler( { case Format::HDF5: return constructIOHandler( - "HDF5", - std::move(initialize_from), - std::move(path), - access, - std::move(options)); + "HDF5", std::move(initialize_from), std::move(options)); case Format::ADIOS2_BP: return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, std::move(options), "file", std::move(originalExtension)); @@ -197,8 +171,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, std::move(options), "bp4", std::move(originalExtension)); @@ -206,8 +178,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, std::move(options), "bp5", std::move(originalExtension)); @@ -215,8 +185,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, std::move(options), "sst", std::move(originalExtension)); @@ -224,8 +192,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "ADIOS2", std::move(initialize_from), - std::move(path), - access, std::move(options), "ssc", std::move(originalExtension)); @@ -233,8 +199,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "JSON", std::move(initialize_from), - std::move(path), - access, std::move(options), JSONIOHandlerImpl::FileFormat::Json, std::move(originalExtension)); @@ -242,8 +206,6 @@ std::unique_ptr createIOHandler( return constructIOHandler( "JSON", std::move(initialize_from), - std::move(path), - access, std::move(options), JSONIOHandlerImpl::FileFormat::Toml, std::move(originalExtension)); @@ -255,17 +217,15 @@ std::unique_ptr createIOHandler( } } -std::unique_ptr createIOHandler( - std::optional> initialize_from, - std::string path, - Access access, +template <> +std::unique_ptr +createIOHandler( + internal::AbstractIOHandlerInitFrom &&initialize_from, Format format, std::string originalExtension) { return createIOHandler( std::move(initialize_from), - std::move(path), - access, format, std::move(originalExtension), json::TracingJSON(json::ParsedConfig{}), 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/DummyIOHandler.cpp b/src/IO/DummyIOHandler.cpp index f3b4e155d2..2147ef8cc1 100644 --- a/src/IO/DummyIOHandler.cpp +++ b/src/IO/DummyIOHandler.cpp @@ -19,19 +19,16 @@ * If not, see . */ #include "openPMD/IO/DummyIOHandler.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/auxiliary/JSON_internal.hpp" -#include -#include #include namespace openPMD { -DummyIOHandler::DummyIOHandler(std::string path, Access at) +DummyIOHandler::DummyIOHandler(internal::AbstractIOHandlerInitFrom &&init_from) : AbstractIOHandler( - std::nullopt, - std::move(path), - at, + std::move(init_from), json::TracingJSON( nlohmann::json::object(), json::SupportedLanguages::JSON)) {} @@ -39,7 +36,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 714a69b9d3..7518452e11 100644 --- a/src/IO/HDF5/HDF5IOHandler.cpp +++ b/src/IO/HDF5/HDF5IOHandler.cpp @@ -1918,6 +1918,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; @@ -3597,37 +3603,31 @@ std::future HDF5IOHandlerImpl::flush(internal::ParsedFlushParams ¶ms) #if openPMD_HAVE_HDF5 HDF5IOHandler::HDF5IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON config) - : AbstractIOHandler( - std::move(initialize_from), std::move(path), at, std::move(config)) + : AbstractIOHandler(std::move(initialize_from), std::move(config)) , m_impl{new HDF5IOHandlerImpl(this)} {} HDF5IOHandler::~HDF5IOHandler() = default; -std::future HDF5IOHandler::flush(internal::ParsedFlushParams ¶ms) +std::future HDF5IOHandler::flush_impl(internal::ParsedFlushParams ¶ms) { return m_impl->flush(params); } #else HDF5IOHandler::HDF5IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON config) - : AbstractIOHandler( - std::move(initialize_from), std::move(path), at, std::move(config)) + : AbstractIOHandler(std::move(initialize_from), std::move(config)) { throw std::runtime_error("openPMD-api built without HDF5 support"); } 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 7de4960feb..fc568e5294 100644 --- a/src/IO/HDF5/ParallelHDF5IOHandler.cpp +++ b/src/IO/HDF5/ParallelHDF5IOHandler.cpp @@ -21,6 +21,7 @@ */ #include "openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp" #include "openPMD/Error.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/FlushParametersInternal.hpp" #include "openPMD/IO/HDF5/HDF5IOHandlerImpl.hpp" #include "openPMD/IO/HDF5/ParallelHDF5IOHandlerImpl.hpp" @@ -59,24 +60,17 @@ namespace openPMD #endif ParallelHDF5IOHandler::ParallelHDF5IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm comm, json::TracingJSON config) - : AbstractIOHandler( - std::move(initialize_from), - std::move(path), - at, - std::move(config), - comm) + : AbstractIOHandler(std::move(initialize_from), std::move(config), comm) , m_impl{new ParallelHDF5IOHandlerImpl(this, comm)} {} 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()) @@ -433,27 +427,18 @@ ParallelHDF5IOHandlerImpl::flush(internal::ParsedFlushParams ¶ms) #if openPMD_HAVE_MPI ParallelHDF5IOHandler::ParallelHDF5IOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm comm, json::TracingJSON config) - : AbstractIOHandler( - std::move(initialize_from), - std::move(path), - at, - std::move(config), - comm) + : AbstractIOHandler(std::move(initialize_from), std::move(config), comm) { throw std::runtime_error("openPMD-api built without HDF5 support"); } #else ParallelHDF5IOHandler::ParallelHDF5IOHandler( - std::optional> initialize_from, - std::string const &path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, json::TracingJSON config) - : AbstractIOHandler(std::move(initialize_from), path, at, std::move(config)) + : AbstractIOHandler(std::move(initialize_from), std::move(config)) { throw std::runtime_error( "openPMD-api built without parallel support and without HDF5 support"); @@ -462,7 +447,8 @@ ParallelHDF5IOHandler::ParallelHDF5IOHandler( ParallelHDF5IOHandler::~ParallelHDF5IOHandler() = default; -std::future ParallelHDF5IOHandler::flush(internal::ParsedFlushParams &) +std::future +ParallelHDF5IOHandler::flush_impl(internal::ParsedFlushParams &) { return std::future(); } diff --git a/src/IO/JSON/JSONIOHandler.cpp b/src/IO/JSON/JSONIOHandler.cpp index c531aabb00..f103a5c47a 100644 --- a/src/IO/JSON/JSONIOHandler.cpp +++ b/src/IO/JSON/JSONIOHandler.cpp @@ -20,40 +20,35 @@ */ #include "openPMD/IO/JSON/JSONIOHandler.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" namespace openPMD { JSONIOHandler::~JSONIOHandler() = default; JSONIOHandler::JSONIOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, openPMD::json::TracingJSON jsonCfg, JSONIOHandlerImpl::FileFormat format, std::string originalExtension) - : AbstractIOHandler{ - std::move(initialize_from), std::move(path), at, std::move(jsonCfg)} + : AbstractIOHandler{std::move(initialize_from), std::move(jsonCfg)} , m_impl{this, format, std::move(originalExtension)} {} #if openPMD_HAVE_MPI JSONIOHandler::JSONIOHandler( - std::optional> initialize_from, - std::string path, - Access at, + internal::AbstractIOHandlerInitFrom &&initialize_from, MPI_Comm comm, openPMD::json::TracingJSON jsonCfg, JSONIOHandlerImpl::FileFormat format, std::string originalExtension) - : AbstractIOHandler{ - std::move(initialize_from), std::move(path), at, std::move(jsonCfg)} + : AbstractIOHandler{std::move(initialize_from), std::move(jsonCfg)} , m_impl{ JSONIOHandlerImpl{this, comm, format, std::move(originalExtension)}} {} #endif -std::future JSONIOHandler::flush(internal::ParsedFlushParams &) +std::future JSONIOHandler::flush_impl(internal::ParsedFlushParams &) { return m_impl.flush(); } diff --git a/src/IO/JSON/JSONIOHandlerImpl.cpp b/src/IO/JSON/JSONIOHandlerImpl.cpp index 7647746d74..9ef7173216 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); diff --git a/src/Iteration.cpp b/src/Iteration.cpp index 67a28c51bc..7b5b599957 100644 --- a/src/Iteration.cpp +++ b/src/Iteration.cpp @@ -306,15 +306,9 @@ void Iteration::flushFileBased( s.openIteration(i, *this); } - switch (flushParams.flushLevel) + if (flush_level::flush_hierarchy(flushParams.flushLevel)) { - case FlushLevel::CreateOrOpenFiles: - break; - case FlushLevel::SkeletonOnly: - case FlushLevel::InternalFlush: - case FlushLevel::UserFlush: flush(flushParams); - break; } } @@ -329,15 +323,9 @@ void Iteration::flushGroupBased( IOHandler()->enqueue(IOTask(this, pCreate)); } - switch (flushParams.flushLevel) + if (flush_level::flush_hierarchy(flushParams.flushLevel)) { - case FlushLevel::CreateOrOpenFiles: - break; - case FlushLevel::SkeletonOnly: - case FlushLevel::InternalFlush: - case FlushLevel::UserFlush: flush(flushParams); - break; } } @@ -352,17 +340,13 @@ void Iteration::flushVariableBased( IOHandler()->enqueue(IOTask(this, pOpen)); } - switch (flushParams.flushLevel) + if (!flush_level::flush_hierarchy(flushParams.flushLevel)) { - case FlushLevel::CreateOrOpenFiles: return; - case FlushLevel::SkeletonOnly: - case FlushLevel::InternalFlush: - case FlushLevel::UserFlush: - flush(flushParams); - break; } + flush(flushParams); + if (!written()) { /* create iteration path */ @@ -395,7 +379,7 @@ void Iteration::flush(internal::FlushParams const &flushParams) m.second.flush(m.first, flushParams); for (auto &species : particles) species.second.flush(species.first, flushParams); - setDirty(false); + determineUnsetDirty(flushParams.flushLevel); } else { @@ -449,9 +433,9 @@ void Iteration::flush(internal::FlushParams const &flushParams) } if (flushParams.flushLevel != FlushLevel::SkeletonOnly) { - setDirty(false); - meshes.setDirty(false); - particles.setDirty(false); + determineUnsetDirty(flushParams.flushLevel); + meshes.determineUnsetDirty(flushParams.flushLevel); + particles.determineUnsetDirty(flushParams.flushLevel); } } diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp new file mode 100644 index 0000000000..6a8c526be6 --- /dev/null +++ b/src/LoadStoreChunk.cpp @@ -0,0 +1,398 @@ + + +#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" +#include "openPMD/auxiliary/UniquePtr.hpp" + +// comment to keep clang-format from reordering +#include "openPMD/DatatypeMacros.hpp" +#include "openPMD/backend/Attributable.hpp" + +#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 + +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::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, + 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()) + { + 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; +} + +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)}); +} + +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."); + } + + 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)}); +} + +auto ConfigureLoadStore::withRawPtr_impl_mut(void *data, Datatype dtype) + -> openPMD::ConfigureLoadStoreFromBuffer +{ + if (!data) + { + throw std::runtime_error( + "Unallocated pointer passed during chunk store."); + } + 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::storeSpan() -> DynamicMemoryView +{ + return m_rc.storeChunkSpan_impl(storeChunkConfig()); +} + +template +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(); + return res_lambda; + }); +} + +struct VisitorEnqueueLoadVariantWithFlush +{ + 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; + }); + } +}; +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> +{ + if (m_unsafeNoAutomaticFlush) + { + return m_rc.visit( + this->storeChunkConfig()); + } + else + { + return m_rc.visit( + this->storeChunkConfig(), deferFlush(m_rc)); + } +} + +struct VisitorLoadVariant +{ + template + static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg) + -> auxiliary::detail::shared_ptr_dataset_types + { + 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 ConfigureStoreChunkFromBuffer::store() + -> auxiliary::DeferredComputation +{ + 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(); }); +} + +auto ConfigureLoadStoreFromBuffer::load() + -> 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()); + if (m_unsafeNoAutomaticFlush) + { + return auxiliary::DeferredComputation( + auxiliary::detail::CachedValue()); + } + return auxiliary::DeferredComputation( + [dflush = this->deferFlush(this->m_rc)]() mutable -> void { + dflush(); + }); +} + +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 ConfigureLoadStore::unsafeNoAutomaticFlush_impl() +{ + m_unsafeNoAutomaticFlush = true; +} + +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[] +#define OPENPMD_POINTER(type) type * +#define OPENPMD_APPLY_TEMPLATE(template_, type) template_ + +#define INSTANTIATE_METHOD_TEMPLATES(dtype) \ + template auto ConfigureLoadStore::load() \ + -> auxiliary::DeferredComputation; +#define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type) \ + INSTANTIATE_METHOD_TEMPLATES(type) \ + INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type)) \ + template auto ConfigureLoadStore::storeSpan() -> DynamicMemoryView; + +OPENPMD_FOREACH_DATASET_DATATYPE( + INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT) + +#undef INSTANTIATE_METHOD_TEMPLATES +#undef INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT + +#undef INSTANTIATE_METHOD_TEMPLATES +#undef OPENPMD_ARRAY +#undef OPENPMD_POINTER +#undef OPENPMD_APPLY_TEMPLATE +} // namespace openPMD diff --git a/src/ParticleSpecies.cpp b/src/ParticleSpecies.cpp index 8a2b9b58f7..718d3e847a 100644 --- a/src/ParticleSpecies.cpp +++ b/src/ParticleSpecies.cpp @@ -197,11 +197,8 @@ void ParticleSpecies::flush( patch.second.flush(patch.first, flushParams); } } - if (flushParams.flushLevel != FlushLevel::SkeletonOnly) - { - particlePatches.setDirty(false); - setDirty(false); - } + determineUnsetDirty(flushParams.flushLevel); + particlePatches.determineUnsetDirty(flushParams.flushLevel); } void ParticleSpecies::scientificDefaults_impl( internal::WriteOrRead, OpenpmdStandard) diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp index ec254d3b99..3a6a4f016c 100644 --- a/src/RecordComponent.cpp +++ b/src/RecordComponent.cpp @@ -22,7 +22,9 @@ #include "openPMD/Dataset.hpp" #include "openPMD/DatatypeHelpers.hpp" #include "openPMD/Error.hpp" +#include "openPMD/IO/AbstractIOHandler.hpp" #include "openPMD/IO/Format.hpp" +#include "openPMD/LoadStoreChunk.hpp" #include "openPMD/Series.hpp" #include "openPMD/auxiliary/Environment.hpp" #include "openPMD/auxiliary/Memory.hpp" @@ -36,6 +38,9 @@ // comment so clang-format does not move this #include "openPMD/DatatypeMacros.hpp" +// comment +#include "openPMD/DatatypeMacros.hpp" + #include #include #include @@ -48,7 +53,8 @@ namespace openPMD namespace internal { RecordComponentData::RecordComponentData() = default; - auto RecordComponentData::push_chunk(IOTask &&task) -> void + void RecordComponentData::push_chunk( + IOTask &&task, std::optional immediate_flush) { Attributable a; a.setData(std::shared_ptr{this, [](auto const &) {}}); @@ -70,8 +76,29 @@ namespace internal "Cannot write/read chunks to/from closed Iterations."); } #endif + bool immediate_flush_resolved = [&]() { + if (immediate_flush.has_value()) + { + return *immediate_flush; + } + else + { + return a.IOHandler()->m_flush_immediately; + } + }(); a.setDirtyRecursive(true); - m_chunks.push(std::move(task)); + if (immediate_flush_resolved) + { + a.seriesFlush_impl( + internal::FlushParams{FlushLevel::ImmediateFlush}); + auto IOHandler = a.IOHandler(); + IOHandler->enqueue(task); + IOHandler->flush(FlushLevel::UserFlush); + } + else + { + m_chunks.push(std::move(task)); + } } static constexpr char const *note_on_deactivating_this_check = R"( @@ -191,6 +218,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) -> UniquePtrWithLambda + { + return UniquePtrWithLambda{ + new T[size], [](auto *ptr) { delete[] ptr; }}; + } +#else + template + auto createSpanBufferFallback(size_t size) -> std::unique_ptr + { + return std::unique_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_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; + for (auto val : e) + { + numPoints *= val; + } + + 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_impl_mut(newData, dtype) + .unsafeNoAutomaticFlush() + .load(); + return newData; +} + RecordComponent::RecordComponent() : BaseRecordComponent(NoInit()) { setData(std::make_shared()); @@ -404,10 +497,15 @@ void RecordComponent::flush( } if (access::readOnly(IOHandler()->m_frontendAccess)) { - while (!rc.m_chunks.empty()) + // sic! this needs to be a separate if term, otherwise flushes may + // wrongly jump into the write branch below + if (flush_level::global_flushpoint(flushParams.flushLevel)) { - IOHandler()->enqueue(rc.m_chunks.front()); - rc.m_chunks.pop(); + while (!rc.m_chunks.empty()) + { + IOHandler()->enqueue(rc.m_chunks.front()); + rc.m_chunks.pop(); + } } } else @@ -525,10 +623,7 @@ void RecordComponent::flush( flushAttributes(flushParams); } - if (flushParams.flushLevel != FlushLevel::SkeletonOnly) - { - setDirty(false); - } + determineUnsetDirty(flushParams.flushLevel); } void RecordComponent::read() @@ -613,19 +708,24 @@ void RecordComponent::readBase() } } -void RecordComponent::storeChunk( - auxiliary::WriteBuffer buffer, Datatype dtype, Offset o, Extent e) +void RecordComponent::storeChunk_impl( + auxiliary::WriteBuffer buffer, + Datatype dtype, + internal::LoadStoreConfigWithBuffer cfg, + std::optional flush_immediately) { + 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))); + rc.push_chunk(IOTask(this, std::move(dWrite)), flush_immediately); } void RecordComponent::verifyChunk( @@ -754,68 +854,80 @@ 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.unsafeNoAutomaticFlush().load().get(); } 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 -void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) +void RecordComponent::loadChunk_impl( + std::shared_ptr const &data, internal::LoadStoreConfigWithBuffer cfg) { - Datatype dtype = determineDatatype(data); + 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()) + { + throw error::WrongAPIUsage( + "Unsupported: Memory selections in chunk loading."); + } /* * For constant components, we implement type conversion, so there is * a separate check further below. @@ -826,35 +938,18 @@ void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) * * 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; throw std::runtime_error(err_msg); } - uint8_t dim = getDimensionality(); - - // 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) - { - extent = getExtent(); - for (uint8_t i = 0u; i < dim; ++i) - extent[i] -= offset[i]; - } - else - extent = e; + auto dim = getDimensionality(); + auto [offset, extent, memorySelection] = std::move(cfg); if (extent.size() != dim || offset.size() != dim) { @@ -873,9 +968,6 @@ void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) "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()) @@ -884,25 +976,8 @@ void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) 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); - } + switchDatasetType( + dtype_requested, data.get(), numPoints, *this, rc); } else { @@ -916,80 +991,80 @@ void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) } template -void RecordComponent::loadChunk( - std::shared_ptr ptr, Offset offset, Extent extent) +void RecordComponent::loadChunk(std::shared_ptr data, Offset o, Extent e) { - loadChunk( - std::static_pointer_cast(std::move(ptr)), - std::move(offset), - std::move(extent)); + // static_assert(!std::is_same_v, "EVIL"); + uint8_t dim = getDimensionality(); + auto operation = prepareLoadStore(); + + // default arguments + // offset = {0u}: expand to right dim {0u, 0u, ...} + if (o.size() != 1u || o.at(0) != 0u || dim <= 1u) + { + operation.offset(std::move(o)); + } + + // extent = {-1u}: take full size + if (e.size() != 1u || e.at(0) != -1u) + { + operation.extent(std::move(e)); + } + + operation.withSharedPtr(std::move(data)).unsafeNoAutomaticFlush().load(); } 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) + .unsafeNoAutomaticFlush() + .load(); } 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)) + .unsafeNoAutomaticFlush() + .store(); } 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)) + .unsafeNoAutomaticFlush() + .store(); } 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) + .unsafeNoAutomaticFlush() + .store(); } 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)) + .storeSpan(); } template @@ -1003,10 +1078,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( \ @@ -1014,21 +1085,28 @@ 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( \ - 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( \ - UniquePtrWithLambda data, Offset o, Extent e); + UniquePtrWithLambda data, Offset o, Extent e); \ + template void RecordComponent::loadChunk_impl( \ + std::shared_ptr const &data, \ + internal::LoadStoreConfigWithBuffer cfg); \ + template std::shared_ptr RecordComponent::loadChunkAllocate_impl( \ + 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/Series.cpp b/src/Series.cpp index 855178c18d..a83334b0b2 100644 --- a/src/Series.cpp +++ b/src/Series.cpp @@ -25,6 +25,7 @@ #include "openPMD/Error.hpp" #include "openPMD/IO/AbstractIOHandler.hpp" #include "openPMD/IO/AbstractIOHandlerHelper.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" #include "openPMD/IO/Access.hpp" #include "openPMD/IO/DummyIOHandler.hpp" #include "openPMD/IO/Format.hpp" @@ -214,8 +215,6 @@ struct Series::ParsedInput std::string filenamePostfix; std::optional filenameExtension; int filenamePadding = -1; - // optional fields - bool verify_homogeneous_extents = true; }; // ParsedInput std::string Series::openPMD() const @@ -523,12 +522,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))); }; @@ -569,7 +569,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 @@ -588,7 +588,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 @@ -791,7 +791,8 @@ void Series::flush(std::string backendConfig) {FlushLevel::UserFlush, std::move(backendConfig)}); } -std::unique_ptr Series::parseInput(std::string filepath) +std::unique_ptr +Series::parseInput(std::string filepath) const { std::unique_ptr input{new Series::ParsedInput}; @@ -941,104 +942,90 @@ void Series::init( // Either an MPI_Comm or none, the template works for both options MPI_Communicator &&...comm) { - auto emplace_parse_config_options_into_iohandler = - [](AbstractIOHandler &ioHandler, ParsedInput &input) { - ioHandler.m_verify_homogeneous_extents = - input.verify_homogeneous_extents; - }; - - auto init_directly = [this, - &comm..., - at, - &filepath, - &emplace_parse_config_options_into_iohandler]( + auto init_directly = [this, &comm..., &filepath]( std::unique_ptr parsed_input, - json::TracingJSON tracing_json) { + json::TracingJSON tracing_json, + internal::GlobalParameters global_parameters) { auto io_handler = createIOHandler( - std::nullopt, - parsed_input->path, - at, + internal::AbstractIOHandlerInitFrom(std::move(global_parameters)), parsed_input->format, parsed_input->filenameExtension.value_or(std::string()), comm..., tracing_json, filepath); - emplace_parse_config_options_into_iohandler(*io_handler, *parsed_input); initSeries(std::move(io_handler), std::move(parsed_input)); json::warnGlobalUnusedOptions(tracing_json); }; - auto init_deferred = [this, - at, - &filepath, - &options, - &emplace_parse_config_options_into_iohandler, - &comm...](std::string const &parsed_directory) { + auto init_deferred = [this, &filepath, &options, &comm...]( + internal::GlobalParameters gp) { // Set a temporary IOHandler so that API calls which require a present // IOHandler don't fail writable().IOHandler = std::make_shared>>( - std::make_unique(parsed_directory, at)); + std::make_unique(std::move(gp))); auto &series = get(); series.iterations.linkHierarchy(writable()); series.m_rankTable.m_attributable.linkHierarchy(writable()); - series.m_deferred_initialization = - [called_this_already = false, - filepath, - options, - at, - emplace_parse_config_options_into_iohandler, - comm...](Series &s) mutable { - if (called_this_already) - { - throw std::runtime_error("Must be called one time only"); - } - else - { - called_this_already = true; - } + series.m_deferred_initialization = [called_this_already = false, + filepath, + options, + comm...](Series &s) mutable { + if (called_this_already) + { + throw std::runtime_error("Must be called one time only"); + } + else + { + called_this_already = true; + } - auto [parsed_input, tracing_json] = - s.initIOHandler( - filepath, - options, - at, - true, - std::forward(comm)...); - - auto &writable = s.get()->m_writable; - - auto io_handler = createIOHandler( - writable.IOHandler ? std::move(*writable.IOHandler) - : std::nullopt, - parsed_input->path, - at, - parsed_input->format, - parsed_input->filenameExtension.value_or(std::string()), - comm..., - tracing_json, - filepath); - emplace_parse_config_options_into_iohandler( - *io_handler, *parsed_input); - auto res = io_handler.get(); - s.initSeries(std::move(io_handler), std::move(parsed_input)); - json::warnGlobalUnusedOptions(tracing_json); - return res; - }; + auto &writable = s.get()->m_writable; + if (!writable.IOHandler) + { + throw error::Internal( + "Temporary IOHandler should be present at this point."); + } + auto [parsed_input, tracing_json] = + s.prepareIOHandlerArguments( + ***writable.IOHandler, + filepath, + options, + true, + std::forward(comm)...); + + auto io_handler = createIOHandler( + internal::AbstractIOHandlerInitFrom( + (**writable.IOHandler).get()), + parsed_input->format, + parsed_input->filenameExtension.value_or(std::string()), + comm..., + tracing_json, + filepath); + auto res = io_handler.get(); + s.initSeries(std::move(io_handler), std::move(parsed_input)); + json::warnGlobalUnusedOptions(tracing_json); + return res; + }; }; + internal::GlobalParameters global_parameters{at}; switch (at) { case Access::CREATE_RANDOM_ACCESS: case Access::READ_WRITE: case Access::READ_ONLY: { - auto [parsed_input, tracing_json] = initIOHandler( - filepath, - options, - at, - true, - std::forward(comm)...); - init_directly(std::move(parsed_input), std::move(tracing_json)); + auto [parsed_input, tracing_json] = + prepareIOHandlerArguments( + global_parameters, + filepath, + options, + true, + std::forward(comm)...); + init_directly( + std::move(parsed_input), + std::move(tracing_json), + std::move(global_parameters)); } break; case Access::CREATE_LINEAR: @@ -1046,16 +1033,18 @@ void Series::init( case Access::APPEND_RANDOM_ACCESS: case Access::APPEND_LINEAR: { auto [first_parsed_input, first_tracing_json] = - initIOHandler( + prepareIOHandlerArguments( + global_parameters, filepath, options, - at, false, std::forward(comm)...); if (first_parsed_input->filenameExtension.has_value()) { init_directly( - std::move(first_parsed_input), std::move(first_tracing_json)); + std::move(first_parsed_input), + std::move(first_tracing_json), + std::move(global_parameters)); } else { @@ -1065,7 +1054,7 @@ void Series::init( * -> Defer the proper initialization of the IO handler up to the * point when we actually need it. */ - init_deferred(first_parsed_input->path); + init_deferred(std::move(global_parameters)); } } break; @@ -1073,21 +1062,25 @@ void Series::init( } template -auto Series::initIOHandler( +auto Series::prepareIOHandlerArguments( + internal::GlobalParameters &gp, std::string const &filepath, std::string const &options, - Access at, bool resolve_generic_extension, MPI_Communicator &&...comm) -> std::tuple, TracingJSON> { auto &series = get(); + auto at = gp.m_frontendAccess; + // This resolves the JSON config from string/file, but does not evaluate it + // yet json::TracingJSON optionsJson = json::parseOptions( options, std::forward(comm)..., /* considerFiles = */ true); auto input = parseInput(filepath); + gp.directory = input->path; if (resolve_generic_extension && input->format == Format::GENERIC && !access::create(at)) { @@ -1153,7 +1146,8 @@ auto Series::initIOHandler( series.m_parseLazily = at == Access::READ_LINEAR; // now check for user-specified options - parseJsonOptions(optionsJson, *input); + // this actually parses the JSON contents resolved previously + parseJsonOptions(optionsJson, *input, gp); if (resolve_generic_extension && !input->filenameExtension.has_value()) { @@ -3166,7 +3160,8 @@ namespace } // namespace template -void Series::parseJsonOptions(TracingJSON &options, ParsedInput &input) +void Series::parseJsonOptions( + TracingJSON &options, ParsedInput &input, internal::GlobalParameters &gp) { auto &series = get(); getJsonOption( @@ -3182,8 +3177,13 @@ void Series::parseJsonOptions(TracingJSON &options, ParsedInput &input) getJsonOption( options, "verify_homogeneous_extents", - input.verify_homogeneous_extents, + gp.m_verify_homogeneous_extents, "OPENPMD_VERIFY_HOMOGENEOUS_EXTENTS"); + getJsonOption( + options, + "flush_immediately", + gp.m_flush_immediately, + "OPENPMD_FLUSH_IMMEDIATELY"); internal::SeriesData::SourceSpecifiedViaJSON rankTableSource; if (getJsonOptionLowerCase(options, "rank_table", rankTableSource.value)) { @@ -3573,6 +3573,16 @@ void Series::visitHierarchy(HierarchyVisitor &v, bool recursive) v(*this); } +bool Series::flushImmediately() const +{ + auto ioHandler = IOHandler(); + if (!ioHandler) + { + return false; + } + return ioHandler->m_flush_immediately; +} + auto Series::currentSnapshot() -> std::optional> { using vec_t = std::vector; diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp new file mode 100644 index 0000000000..39af555f9e --- /dev/null +++ b/src/auxiliary/Future.cpp @@ -0,0 +1,190 @@ +#include "openPMD/auxiliary/Future.hpp" +#include "openPMD/Error.hpp" +#include "openPMD/RecordComponent.hpp" + +#include +#include +#include + +// comment + +#include "openPMD/DatatypeMacros.hpp" + +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 (!members.m_task_valid) + { + throw error::WrongAPIUsage( + "[DeferredComputation] No valid state. Probably already " + "computed."); + } + if (!members.m_task) + { + throw error::WrongAPIUsage( + "[DeferredComputation] No valid task was specified."); + } + members.m_task_valid = false; + if constexpr (std::is_void_v) + { + std::move(members.m_task)(); + members.m_task = {}; + } + else + { + auto res = std::move(members.m_task)(); + members.m_task = {}; // reset + return res; + } +} +} // namespace openPMD::auxiliary::detail + +namespace openPMD::auxiliary +{ + +template +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() = default; + +template +DeferredComputation::DeferredComputation(DeferredComputation &&) noexcept( + noexcept_move) = default; + +template +auto DeferredComputation::operator=(DeferredComputation &&) noexcept( + noexcept_move) -> DeferredComputation & = default; + +template +DeferredComputation::~DeferredComputation() +{ + try + { + std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) { + if (task.members.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 (...) + { + std::cerr << "[DeferredComputation] Unknown error in destructor." + << std::endl; + } +} + +template +auto DeferredComputation::get() -> T +{ + return std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) -> T { return std::move(task)(); }, + [](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); +} + +template +auto DeferredComputation::operator()() -> T +{ + return get(); +} + +template +void DeferredComputation::invalidate() && +{ + std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask &task) { + task.members.m_task = {}; + task.members.m_task_valid = false; + }, + [](detail::CachedValue const &) {}}, + this->m_task); +} + +template +auto DeferredComputation::valid() const noexcept -> bool +{ + return std::visit( + auxiliary::overloaded{ + [](detail::OneTimeTask const &task) { + return task.members.m_task_valid; + }, + [](detail::CachedValue const &) { return true; }}, + this->m_task); +} + +template class DeferredComputation; +template class DeferredComputation; +template class DeferredComputation; // used in tests + +// need this for clang-tidy +#define OPENPMD_ARRAY(type) type[] +#define OPENPMD_APPLY_TEMPLATE(template_, type) template_ + +#define INSTANTIATE_FUTURE(dtype) \ + 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 +#undef OPENPMD_ARRAY +#undef OPENPMD_APPLY_TEMPLATE +} // namespace openPMD::auxiliary + +#include "openPMD/UndefDatatypeMacros.hpp" diff --git a/src/auxiliary/Memory.cpp b/src/auxiliary/Memory.cpp index c2a0f2aa0d..b002288a88 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,12 +219,22 @@ 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 &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) +WriteBuffer &WriteBuffer::operator=(UniquePtrWithLambda ptr) { m_buffer = std::make_any(CopyableUniquePtr(std::move(ptr))); @@ -226,4 +251,22 @@ void const *WriteBuffer::get() const }, as_variant()); } + +#define OPENPMD_INSTANTIATE(dtype) \ + template WriteBuffer::WriteBuffer(std::shared_ptr); \ + template WriteBuffer &WriteBuffer::operator=( \ + std::shared_ptr const &); + +#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); +template WriteBuffer & +WriteBuffer::operator=(std::shared_ptr const &); + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +#undef OPENPMD_INSTANTIATE } // namespace openPMD::auxiliary diff --git a/src/auxiliary/UniquePtr.cpp b/src/auxiliary/UniquePtr.cpp index 6625ca3a47..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 @@ -99,12 +99,16 @@ 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_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; +template class UniquePtrWithLambda; #undef OPENPMD_INSTANTIATE #undef OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT #undef OPENPMD_ARRAY diff --git a/src/backend/Attributable.cpp b/src/backend/Attributable.cpp index d19fa31a00..2ee68506ce 100644 --- a/src/backend/Attributable.cpp +++ b/src/backend/Attributable.cpp @@ -355,15 +355,9 @@ Attributable::seriesFlush_impl(internal::FlushParams const &flushParams); void Attributable::flushAttributes(internal::FlushParams const &flushParams) { - switch (flushParams.flushLevel) + if (!flush_level::write_attributes(flushParams.flushLevel)) { - case FlushLevel::SkeletonOnly: - case FlushLevel::CreateOrOpenFiles: return; - case FlushLevel::InternalFlush: - case FlushLevel::UserFlush: - // pass - break; } if (dirty()) { @@ -377,10 +371,7 @@ void Attributable::flushAttributes(internal::FlushParams const &flushParams) } } // Do this outside the if branch to also setDirty to dirtyRecursive - if (flushParams.flushLevel != FlushLevel::SkeletonOnly) - { - setDirty(false); - } + determineUnsetDirty(flushParams.flushLevel); } void Attributable::readAttributes(ReadMode mode) diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp index c4eab2318f..c881a48467 100644 --- a/src/backend/BaseRecord.cpp +++ b/src/backend/BaseRecord.cpp @@ -798,10 +798,7 @@ inline void BaseRecord::flush( } this->flush_impl(name, flushParams); - if (flushParams.flushLevel != FlushLevel::SkeletonOnly) - { - this->setDirty(false); - } + this->determineUnsetDirty(flushParams.flushLevel); // flush_impl must take care to correctly set the dirty() flag so this // method doesn't do it } diff --git a/src/backend/PatchRecord.cpp b/src/backend/PatchRecord.cpp index 740f44cc51..7d68b16035 100644 --- a/src/backend/PatchRecord.cpp +++ b/src/backend/PatchRecord.cpp @@ -70,10 +70,7 @@ void PatchRecord::flush_impl( } else T_RecordComponent::flush(path, flushParams); - if (flushParams.flushLevel != FlushLevel::SkeletonOnly) - { - setDirty(false); - } + determineUnsetDirty(flushParams.flushLevel); } void PatchRecord::read() 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)); diff --git a/src/binding/python/Series.cpp b/src/binding/python/Series.cpp index 7054d3755b..31bc54653b 100644 --- a/src/binding/python/Series.cpp +++ b/src/binding/python/Series.cpp @@ -55,6 +55,12 @@ namespace internal { +char const *python_defaults = R"( + { + "flush_immediately": true + } + )"; + struct DefineSeriesConstructorPerPathType { static constexpr auto json_cfg_as_string(std::string const &str) @@ -127,7 +133,8 @@ struct DefineSeriesConstructorPerPathType decltype(auto) filepath_ = filepath_as_string(filepath); decltype(auto) options_ = json_cfg_as_string(options); py::gil_scoped_release release; - return new Series(filepath_, at, options_); + return new Series( + filepath_, at, json::merge(python_defaults, options_)); }), py::arg("filepath"), py::arg("access"), @@ -222,7 +229,7 @@ It will be replaced with an automatically determined file name extension: filepath_, at, std::get(variant), - options_); + json::merge(python_defaults, options_)); } }), py::arg("filepath"), diff --git a/test/AuxiliaryTest.cpp b/test/AuxiliaryTest.cpp index ee0b029473..28c9fbe09c 100644 --- a/test/AuxiliaryTest.cpp +++ b/test/AuxiliaryTest.cpp @@ -19,6 +19,9 @@ * If not, see . */ // expose private and protected members for invasive testing +#include "openPMD/Error.hpp" +#include "openPMD/IO/AbstractIOHandler_internal.hpp" +#include "openPMD/auxiliary/Future.hpp" #if openPMD_USE_INVASIVE_TESTS #define OPENPMD_private public: #define OPENPMD_protected public: @@ -49,6 +52,12 @@ using namespace openPMD; +auto wrapAccess(openPMD::Access at) + -> openPMD::internal::AbstractIOHandlerInitFrom +{ + return openPMD::internal::GlobalParameters{at}; +} + namespace openPMD::test { struct TestHelper : public Attributable @@ -58,7 +67,7 @@ struct TestHelper : public Attributable writable().IOHandler = std::make_shared>>( createIOHandler( - std::nullopt, ".", Access::CREATE, Format::JSON, ".json")); + wrapAccess(Access::CREATE), Format::JSON, ".json")); } }; } // namespace openPMD::test @@ -173,8 +182,7 @@ TEST_CASE("container_default_test", "[auxiliary]") Container c = Container(); c.writable().IOHandler = std::make_shared>>( - createIOHandler( - std::nullopt, ".", Access::CREATE, Format::JSON, ".json")); + createIOHandler(wrapAccess(Access::CREATE), Format::JSON, ".json")); REQUIRE(c.empty()); REQUIRE(c.erase("nonExistentKey") == false); @@ -214,8 +222,7 @@ TEST_CASE("container_retrieve_test", "[auxiliary]") Container c = Container(); c.writable().IOHandler = std::make_shared>>( - createIOHandler( - std::nullopt, ".", Access::CREATE, Format::JSON, ".json")); + createIOHandler(wrapAccess(Access::CREATE), Format::JSON, ".json")); structure s; std::string text = @@ -289,8 +296,7 @@ TEST_CASE("container_access_test", "[auxiliary]") Container c = Container(); c.writable().IOHandler = std::make_shared>>( - createIOHandler( - std::nullopt, ".", Access::CREATE, Format::JSON, ".json")); + createIOHandler(wrapAccess(Access::CREATE), Format::JSON, ".json")); c["1firstWidget"] = Widget(0); REQUIRE(c.size() == 1); @@ -538,3 +544,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); +} diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp index 821907b38e..dcbacfbf52 100644 --- a/test/CoreTest.cpp +++ b/test/CoreTest.cpp @@ -1144,8 +1144,10 @@ TEST_CASE("wrapper_test", "[core]") std::shared_ptr storeData = std::make_shared(44); o.iterations[5].meshes["E"]["y"].storeChunk(storeData, {0}, {1}); #if openPMD_USE_INVASIVE_TESTS - REQUIRE(o.iterations[5].meshes["E"]["y"].get().m_chunks.size() == 1); - REQUIRE(mrc3.get().m_chunks.size() == 1); + size_t num_chunks = o.IOHandler()->m_flush_immediately ? 0 : 1; + REQUIRE( + o.iterations[5].meshes["E"]["y"].get().m_chunks.size() == num_chunks); + REQUIRE(mrc3.get().m_chunks.size() == num_chunks); #endif o.flush(); #if openPMD_USE_INVASIVE_TESTS @@ -1198,9 +1200,10 @@ TEST_CASE("wrapper_test", "[core]") .particles["electrons"] .particlePatches["numParticles"][RecordComponent::SCALAR] .get() - .m_chunks.size() == 1); + .m_chunks.size() == num_chunks); REQUIRE( - pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() == 1); + pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() == + num_chunks); #endif std::stringstream u64str; u64str << determineDatatype(); @@ -1222,9 +1225,10 @@ TEST_CASE("wrapper_test", "[core]") .particles["electrons"] .particlePatches["numParticles"][RecordComponent::SCALAR] .get() - .m_chunks.size() == 2); + .m_chunks.size() == num_chunks * 2); REQUIRE( - pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() == 2); + pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() == + num_chunks * 2); #endif o.flush(); #if openPMD_USE_INVASIVE_TESTS @@ -1267,11 +1271,13 @@ TEST_CASE("use_count_test", "[core]") std::shared_ptr storeData = std::make_shared(44); REQUIRE(storeData.use_count() == 1); mrc.storeChunk(storeData, {0}, {1}); - REQUIRE(storeData.use_count() == 2); +#if openPMD_USE_INVASIVE_TESTS + long additional_internal_use_count = + o.IOHandler()->m_flush_immediately ? 0 : 1; + REQUIRE(storeData.use_count() == (1 + additional_internal_use_count)); o.flush(); REQUIRE(storeData.use_count() == 1); -#if openPMD_USE_INVASIVE_TESTS PatchRecordComponent pprc = o.iterations[6] .particles["electrons"] @@ -1285,12 +1291,19 @@ TEST_CASE("use_count_test", "[core]") .resetDataset(dset); pprc.resetDataset(Dataset(determineDatatype(), {4})); pprc.store(0, static_cast(1)); - REQUIRE( - std::get>( - static_cast *>( - pprc.get().m_chunks.front().parameter.get()) - ->data.as_variant()) - .use_count() == 1); + if (o.IOHandler()->m_flush_immediately) + { + REQUIRE(pprc.get().m_chunks.empty()); + } + else + { + REQUIRE( + std::get>( + static_cast *>( + pprc.get().m_chunks.front().parameter.get()) + ->data.as_variant()) + .use_count() == 1); + } #endif } diff --git a/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp b/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp index 5b62949e62..855e152766 100644 --- a/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp +++ b/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp @@ -39,6 +39,11 @@ auto worker(std::string const &ext) -> void std::string filename = "../samples/ptl_%T." + ext; Series series = Series(filename, Access::CREATE_LINEAR, MPI_COMM_WORLD); + if (series.flushImmediately()) + { + // Cannot run this test in immediate flush mode + return; + } Datatype datatype = determineDatatype(); diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp index 9c28f52945..834e826e8b 100644 --- a/test/ParallelIOTest.cpp +++ b/test/ParallelIOTest.cpp @@ -148,6 +148,12 @@ void write_test_zero_extent( Access::CREATE_LINEAR, MPI_COMM_WORLD); + if (o.flushImmediately() && !writeAllChunks) + { + // immediate flushing makes storeChunk collective, cannot do this + return; + } + int const max_step = 100; for (int step = 0; step <= max_step; step += 20) @@ -454,18 +460,51 @@ 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}) + .store(); + E_y.prepareLoadStore() + .offset({1, 3ul * mpi_rank}) + .extent({3, 3}) + .withContiguousContainer(ydata) + .memorySelection({{1, 1}, {5, 5}}) + .store(); + // 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}) + .store(); + } it0.close(); } { - 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(); @@ -492,6 +531,41 @@ 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}).load().get(); + auto middle_rows = E_y.prepareLoadStore() + .offset({1, 0}) + .extent({3, width}) + .load() + .get(); + auto last_row = E_y.prepareLoadStore().offset({4, 0}).load().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); + } } } @@ -842,8 +916,25 @@ void close_iteration_test(std::string const &file_ending) { REQUIRE(data[i % 4] == chunk.get()[i]); } - auto read_again = E_x_read.loadChunk({0, 0}, {mpi_size, 4}); - // REQUIRE_THROWS(read.flush()); + // Cannot write/read chunks to/from closed Iterations. + if (read.flushImmediately()) + { +#if openPMD_USE_INVASIVE_TESTS + REQUIRE_THROWS_WITH( + E_x_read.loadChunk({0, 0}, {mpi_size, 4}), + "Cannot write/read chunks to/from closed Iterations."); +#else + REQUIRE_THROWS_WITH( + E_x_read.loadChunk({0, 0}, {mpi_size, 4}), + "Wrong API usage: [Series] Closed iteration (idx=1) must be " + "open()ed explicitly before interacting with it again."); +#endif + } + else + { + auto read_again = E_x_read.loadChunk({0, 0}, {mpi_size, 4}); + // REQUIRE_THROWS(read.flush()); + } } chunk_assignment::RankMeta compare; diff --git a/test/SerialIOTest.cpp b/test/SerialIOTest.cpp index 49aab1db18..03c5746a1c 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_()) + .store(); // 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().loadVariant().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) @@ -4343,6 +4351,7 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep) Datatype dtype = determineDatatype(); { Series write("../samples/bp5_flush.bp", Access::CREATE_LINEAR, cfg); + bool flushImmediately = write.flushImmediately(); { auto component = @@ -4379,8 +4388,16 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep) if (flushDuringStep == FlushDuringStep::Default_Yes || flushDuringStep == FlushDuringStep::Always) { - // should still be roughly within 1% of 4Mb - REQUIRE(std::abs(1 - double(currentSize) / (4 * size)) <= 0.01); + if (flushImmediately) + { + // should still be roughly within 1% of 8Mb + REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01); + } + else + { + // should still be roughly within 1% of 4Mb + REQUIRE(std::abs(1 - double(currentSize) / (4 * size)) <= 0.01); + } } else { @@ -4420,8 +4437,17 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep) } else if (flushDuringStep == FlushDuringStep::Default_Yes) { - // should now be roughly within 1% of 8Mb - REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01); + if (flushImmediately) + { + // should now be roughly within 1% of 12Mb + REQUIRE( + std::abs(1 - double(currentSize) / (12 * size)) <= 0.01); + } + else + { + // should now be roughly within 1% of 8Mb + REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01); + } } else {