Adios2

Latest version: v2.10.1.100042

Safety actively analyzes 701396 Python packages for vulnerabilities to keep your Python projects secure.

Scan your dependencies

Page 4 of 5

2.6.0

Summary
This is a major release with a wide variety of features in all areas including staging, file I/O, build system, and many others.

Features
Build System
* When enabling MPI the build system now generates both serial and parallel libraries. One installation of ADIOS is needed only for building both parallel and serial applications
* CMake targets now support components for each supported language, i.e. instead of just `adios2` there are now `adios2::cxx11` and `adios2::cxx11_mpi`
* All third party dependencies can now be provided externally rather than use internal copies

Engines
* BP4 Engine: Burst buffer support for writing. File on the final target file system can still be read step-by-step in situ by other apps. Appending to an existing file, however, is NOT supported.
* New engine SSC: MPI-based engine for code coupling and in situ processing
* DataMan engine: new reliable mode, that guarantees that every step arrives at the reader
* Inline engine: is now being elevated from experimental to beta.
* SST engine:
* With the non-RDMA transport, IP Port range now defaults to "any", rather than "26000-26100". (The desired range can be specified with the ADIOS2_PORT_RANGE environment variable, see [sst_conn_tool documentation](https://adios2.readthedocs.io/en/latest/ecosystem/utilities.html#sst-conn-tool-sst-network-connectivity-tool) for more information.)
* SST now has a "push mode" where written data is pro-actively sent to readers without waiting for specific requests. This "push mode" is either **speculative** (based on an assumption that data will be used) or **learned** (based on actual usage).
* Speculative push mode is enabled automatically in certain circumstances, managed by [SST engine parameters](https://adios2.readthedocs.io/en/latest/engines/engines.html#sst-sustainable-staging-transport) SpeculativePreloadMode and SpecAutoNodeThreshold.
* Learned preload mode is triggered when the reader and writer indicate that their data consumption/production patterns are static by calling [LockReaderSelections](https://adios2.readthedocs.io/en/latest/api_full/api_full.html?highlight=LockReaderSelections#_CPPv4N6adios26Engine20LockReaderSelectionsEv) and [LockWriterDefinitions](https://adios2.readthedocs.io/en/latest/api_full/api_full.html?highlight=LockWriterDefinitions#_CPPv4N6adios26Engine21LockWriterDefinitionsEv), respectively.

API Changes (do not break compilation)
* `DebugMode` now deprecated from the public constructor and factory interfaces. In previous releases this flag controlled enabling or disabling additional error checking. Through extensive bench-marking of API calls it was determined that the savings was negligible so the appropriate error checking (null pointer, bounds, etc.) is now always performed within API calls and throwing exceptions (in C++) or returning error codes (C and Fortran) where appropriate.
* Python `available_variables()` now has a filter list argument: `available_variables(['type'])` will return faster but only provides names and types of variables. For backward compatibility, `available_variables()` without arguments is identical to a call with the full list `available_variables(['Type', 'Min', 'Max', 'SingleValue','Shape','AvailableStepsCount'])`. The filter names are case-insensitive.
* YAML configuration file. `adios2::ADIOS` constructor can now accept a configuration file using the YAML format and it must have the `*.yaml` or `*.yml` extension. See [section in docs](https://adios2.readthedocs.io/en/latest/components/components.html#yaml).

2.5.0

Summary
ADIOS v2.5.0, September 30th 2019 This release should be considered stable and suitable for deployment. We highly recommend migration to this version for long term support and future API compatibility. This is a major update which includes the introduction of a new directory-based file format, BP4, for the default Engine targeting streaming through files applications.

Features
* Virtual Engines (File, FileStream, InSituAnalysis, InSituVisualization, CodeCoupling)
* BP4 file engine has a constant append time of new steps. Faster than creating new output at every step.
* Default is now the BP4 file engine that supports reading streaming concurrently while the writer is still producing new steps
* Zero-copy access to the engine buffer memory in Write mode. Uses Variable<T>::Span per Engine Put block, based on upcoming [C++20 std::span](https://en.cppreference.com/w/cpp/container/span). Available in BP3 (since v2.4.0) and BP4 (since v2.5.0) Engines C++ APIs only.

API Breakage
* Python high-level API: ability to retrieve single global values as numpy's 0-dimension array **This breaks API compatibility with v2.4.0 Python high-level API**

2.4.0

Summary
ADIOS v2.4.0, June 30th 2019. This release should be considered stable and suitable for deployment. We highly recommend migration to this version for long term support and future API compatibility.

Features
* Automatic conversion to fixed width types (`int` -> `int32_t`), in all bindings to facilitate portable types and `bpls` output
* MPI library "serial" functionality. ADIOS2 library compiled with MPI can run with code not invoking `MPI_Init` and `MPI_Finalize` running in serial. Requires linking with MPI for symbols.
* Stable high-level APIs in Python and C++ supporting local variables
* Zero-copy access to the engine buffer memory in Write mode. Uses `Variable<T>::Span` per Engine Put block, based on upcoming [C++20 std::span](https://en.cppreference.com/w/cpp/container/span). Available in BP3 Engine C++ APIs only.
* New functionality in Fortran and C APIs for safer handling of subroutines/functions outputting strings
* Addition of no-op backends to disable selected functionality and / or evaluate the performance impact of various layers
- `null` Engine : Bypass all library actions as soon as possible, often in the high-level language bindings before the core library is even reached
- `nullcore` Engine: Implemented in the core of the library allowing the front-end data management and variable operations to occur but to transparently ignore all write and buffering requests.
- `null` Transport : For use with the BP engines, this will bypass all disk I/O operations. All of the data management and buffering will still occur but there will be no actual data written to a file.
* Optimization of data exchanges in the SST engine when a fixed data exchange pattern is specified via LockWriterDefinitions/LockReaderSelections
* PreciousFirstTimestep engine mode allows saving mesh and other one-time-output in a stream, so that late-comer readers can properly initialize from the first input step. Available in SST engine only.
* Added support for MemorySelection for reading into non-contiguous memory (e.g. ghost cells). Available in BP3 Engine only.
* Fixed several bugs: substreams aggregation, endian interoperability, local variables and `bpls`
* Complete redesign of [the user guide documentation in readthedocs](https://adios2.readthedocs.io)
* Added several new lossless compression plugins in BP buffer: `bzip2`, `libpng`, `blosc`. Available in BP and SST engines only.
* Availability of tools interface with connection to TAU 2.28 or greater.

Changes

* LatestAvailable reading mode has been removed from BeginStep() and is now specified at Open() with AlwaysProvideLatestTimestep engine parameter. This allows for more optimized queueing behavior in staging engines. **This breaks API compatibility with v2.3.x**

* IO.LockDefinitions() function has been removed and replaced with Engine.LockWriterDefinitions() and Engine.LockReaderSelections() to improve clarity and separate functionality. As before, calling these functions informs ADIOS2 that the write/read pattern between two applications in staging is unchanging from timestep to timestep (after the calls). This allows certain optimizations, such as eliminating some metadata exchanges and pre-loading data to the readers. **This breaks API compatibility with v2.3.x**

* Data queueing in the SST engine has been redesigned, adding more explicit support for retaining timesteps for late-arriving readers (see the ReserveQueueLimit engine parameter), but also changing the way timesteps are handled when there are no readers present. In the no-readers case, specifying QueueFullPolicy:Blocking will no longer cause SST to pause until a reader arrives. **This behavior is a change from v2.3.x**

2.4.0rc1

Summary
This is a release candidate for the upcoming v2.4.0 release in June 30th 2019. The v2.4.0-rc1 release should be considered stable and suitable for testing deployment as a module on HPC platforms. We recommend users to migrate to this version to test for the upcoming v2.4.0 and report any outstanding issue.

Features
* Moved completely to fix width types in all bindings to facilitate portable types and bpls output
* Stable high-level APIs for Python and C++ supporting local variables
* Added NULL Engine to measure Engine overall overhead
* `Variable<T>::Span` provide access to the engine buffer memory in Write mode (C++ APIs) similar to C++20 `std::span` of a `std::vector`
* New functionality in Fortran and C APIs for handling strings in a safer mode
* Fixed several bugs: Substreams aggregation, endian interoperability, bpls
* Update documentation: adios2.readthedocs.io

2.3.1

Summary
This is a bug-fix release on top of the `v2.3.0` release. The v2.3.1 release should be considered stable and suitable for deployment as a module on HPC platforms.

Features
Bug fixes beyond the `v2.3.0` release include:
* Various CMake fixes
* 1203 1204
* Statically generate adios2-config at install time so cmake and python are no longer required
* 1172 1191
* Various bpls bug fixes
* 1175 1182 1211
* Add missing attributes to high level API
* 1146 1197
* Various SST bug fixes
* 1157 1167 1152 1151 1149 1186 1183 1201 1207 1213
* HDF5 Single value attributes
* 1159
* MGARD tweaks
* 1196

2.3.0

Summary
This is the first production release of the ADIOS v2.x branch. At this point, all public APIs can be considered fairly stable. This also marks the official transition from ADIOS v1.x to v2.x, thus v1.x should now be considered deprecated.

Features
Major additions from the previous v2.2 Beta release include:

* Additional testing added reaching over 300 test covering both low level unit tests and higher level mini-app use-cases.
* APIs for local array handling (each rank is an independent chunk of data instead of a smaller piece in a global index space)
* The dissemination of per-rank write block information so a reader can know which pieces of a variable were written by which rank and optimize their read selection accordingly.
* An extensive list of bug fixes.

Page 4 of 5

© 2025 Safety CLI Cybersecurity Inc. All Rights Reserved.