Classes | |
| struct | ADIOS2FlushParams |
Public Types | |
| enum class | StreamStatus { DuringStep , OutsideOfStep , StreamOver , ReadWithoutStream , Undecided } |
| using | ParsePreference = Parameter< Operation::OPEN_FILE >::ParsePreference |
| using | AttributeMap_t = std::map< std::string, adios2::Params > |
Public Member Functions | |
| ADIOS2File (ADIOS2File const &)=delete | |
| ADIOS2File (ADIOS2IOHandlerImpl &impl, InvalidatableFile file) | |
| void | finalize () |
| Implementation of destructor, will only run once. | |
| UseGroupTable | detectGroupTable () |
| adios2::Engine & | getEngine () |
| template<typename BA > | |
| void | enqueue (BA &&ba) |
| template<typename BA > | |
| void | enqueue (BA &&ba, decltype(m_buffer) &buffer) |
| template<typename... Args> | |
| void | flush (Args &&...args) |
| void | flush_impl (ADIOS2FlushParams flushParams, std::function< void(ADIOS2File &, adios2::Engine &)> const &performPutGets, bool writeLatePuts, bool flushUnconditionally) |
| Flush deferred IO actions. More... | |
| void | flush_impl (ADIOS2FlushParams, bool writeLatePuts=false) |
| Overload of flush() that uses adios2::Engine::Perform(Puts|Gets) and does not flush unconditionally. | |
| AdvanceStatus | advance (AdvanceMode mode) |
| Begin or end an ADIOS step. More... | |
| void | drop () |
| AttributeMap_t const & | availableAttributes () |
| std::vector< std::string > | availableAttributesPrefixed (std::string const &prefix) |
| void | invalidateAttributesMap () |
| AttributeMap_t const & | availableVariables () |
| std::vector< std::string > | availableVariablesPrefixed (std::string const &prefix) |
| void | invalidateVariablesMap () |
| void | markActive (Writable *) |
| size_t | currentStep () |
Public Attributes | |
| std::string | m_file |
| The full path to the file created on disk, including the containing directory and the file extension, as determined by ADIOS2IOHandlerImpl::fileSuffix(). More... | |
| std::string | m_IOName |
| ADIOS requires giving names to instances of adios2::IO. More... | |
| adios2::ADIOS & | m_ADIOS |
| adios2::IO | m_IO |
| std::vector< std::unique_ptr< BufferedAction > > | m_buffer |
| The default queue for deferred actions. More... | |
| std::vector< BufferedUniquePtrPut > | m_uniquePtrPuts |
| When receiving a unique_ptr, we know that the buffer is ours and ours alone. More... | |
| std::vector< std::unique_ptr< BufferedAction > > | m_alreadyEnqueued |
| This contains deferred actions that have already been enqueued into ADIOS2, but not yet performed in ADIOS2. More... | |
| adios2::Mode | m_mode |
| std::map< unsigned, std::unique_ptr< I_UpdateSpan > > | m_updateSpans |
| The base pointer of an ADIOS2 span might change after reallocations. More... | |
| std::set< std::string > | uncommittedAttributes |
| bool | optimizeAttributesStreaming = false |
| ParsePreference | parsePreference = ParsePreference::UpFront |
| StreamStatus | streamStatus = StreamStatus::OutsideOfStep |
Friends | |
| struct | BufferedGet |
| struct | BufferedPut |
| struct | RunUniquePtrPut |
| struct | WriteDataset |
Member Enumeration Documentation
◆ StreamStatus
|
strong |
| Enumerator | |
|---|---|
| DuringStep | A step is currently active. |
| OutsideOfStep | A stream is active, but no step. |
| StreamOver | Stream has ended. |
| ReadWithoutStream | File is not written is streaming fashion. Begin/EndStep will be replaced by simple flushes. Used for: 1) Writing BP4 files without steps despite using the Streaming API. This is due to the fact that ADIOS2.6.0 requires using steps to read BP4 files written with steps, so using steps is opt-in for now. Notice that while the openPMD API requires ADIOS >= 2.7.0, the resulting files need to be readable from ADIOS 2.6.0 as well. This workaround is hence staying until switching to a new ADIOS schema. 2) Reading with the Streaming API any file that has been written without steps. This is not a workaround since not using steps, while inefficient in ADIOS2, is something that we support. |
| Undecided | The stream status of a file-based engine will be decided upon opening the engine if in read mode. Up until then, this right here is the status. |
Member Function Documentation
◆ advance()
| AdvanceStatus openPMD::detail::ADIOS2File::advance | ( | AdvanceMode | mode | ) |
Begin or end an ADIOS step.
- Parameters
-
mode Whether to begin or end a step.
- Returns
- AdvanceStatus
◆ flush_impl()
| void openPMD::detail::ADIOS2File::flush_impl | ( | ADIOS2FlushParams | flushParams, |
| std::function< void(ADIOS2File &, adios2::Engine &)> const & | performPutGets, | ||
| bool | writeLatePuts, | ||
| bool | flushUnconditionally | ||
| ) |
Flush deferred IO actions.
- Parameters
-
flushParams Flush level and target. performPutGets A functor that takes as parameters (1) *this and (2) the ADIOS2 engine. Its task is to ensure that ADIOS2 performs Put/Get operations. Several options for this: - adios2::Engine::EndStep
- adios2::Engine::Perform(Puts|Gets)
- adios2::Engine::Close
writeLatePuts Deferred until right before Engine::EndStep() or Engine::Close(): Running unique_ptr Put()s. flushUnconditionally Whether to run the functor even if no deferred IO tasks had been queued.
Member Data Documentation
◆ m_alreadyEnqueued
| std::vector<std::unique_ptr<BufferedAction> > openPMD::detail::ADIOS2File::m_alreadyEnqueued |
This contains deferred actions that have already been enqueued into ADIOS2, but not yet performed in ADIOS2.
We must store them somewhere until the next PerformPuts/Gets, EndStep or Close in ADIOS2 to avoid use after free conditions.
◆ m_buffer
| std::vector<std::unique_ptr<BufferedAction> > openPMD::detail::ADIOS2File::m_buffer |
The default queue for deferred actions.
Drained upon ADIOS2File::flush().
◆ m_file
| std::string openPMD::detail::ADIOS2File::m_file |
The full path to the file created on disk, including the containing directory and the file extension, as determined by ADIOS2IOHandlerImpl::fileSuffix().
(Meaning, in case of the SST engine, no file suffix since the SST engine automatically adds its suffix unconditionally)
◆ m_IOName
| std::string openPMD::detail::ADIOS2File::m_IOName |
ADIOS requires giving names to instances of adios2::IO.
We make them different from the actual file name, because of the possible following workflow:
- create file foo.bp -> would create IO object named foo.bp
- delete that file (let's ignore that we don't support deletion yet and call it preplanning)
- create file foo.bp a second time -> would create another IO object named foo.bp -> craash
So, we just give out names based on a counter for IO objects. Hence, next to the actual file name, also store the name for the IO.
◆ m_uniquePtrPuts
| std::vector<BufferedUniquePtrPut> openPMD::detail::ADIOS2File::m_uniquePtrPuts |
When receiving a unique_ptr, we know that the buffer is ours and ours alone.
So, for performance reasons, show the buffer to ADIOS2 as late as possible and avoid unnecessary data copies in BP5 triggered by PerformDataWrites().
◆ m_updateSpans
| std::map<unsigned, std::unique_ptr<I_UpdateSpan> > openPMD::detail::ADIOS2File::m_updateSpans |
The base pointer of an ADIOS2 span might change after reallocations.
The frontend will ask the backend for those updated base pointers. Spans given out by the ADIOS2 backend to the frontend are hence identified by an unsigned integer and stored in this member for later retrieval of the updated base pointer. This map is cleared upon flush points.
The documentation for this class was generated from the following files:
- /home/docs/checkouts/readthedocs.org/user_builds/openpmd-api/checkouts/latest/include/openPMD/IO/ADIOS/ADIOS2File.hpp
- /home/docs/checkouts/readthedocs.org/user_builds/openpmd-api/checkouts/latest/src/IO/ADIOS/ADIOS2File.cpp
