v1.0.0

The most visible changes in this release are:

• Umpire is MPI-aware (outputs rank information to logs and replays) when
  configured with the option ENABLE_MPI=On, and umpire::initialize(MPI_Comm comm) must be called.

• AllocationStrategies may be wrapped with multiple extra layers. To "unwrap" an
  Allocator to a specific strategy, the umpire::util::unwrap_allocator method
  can be used, for example:

  auto dynamic_pool =
    umpire::util::unwrap_allocator<umpire::strategy::DynamicPool>(allocator);

This will impact users who have been using DynamicPool::coalesce. The cookbook
recipe has been updated accordingly, and the previous code snippet can be
used.

• Umpire now directs log and replay output to files, one per process. The
  filenames can be controlled by the environment variable UMPIRE_OUTPUT_BASENAME

• ENABLE_CUDA now set to Off by default.

• Allocations for 0 bytes now always return a valid pointer that cannot be read
  or written. These pointers can be deallocated.

Please see CHANGELOG.md for the complete set of changes.

v0.3.5

Fixed

• Off by one regression introduced in 0.3.4 in
  AllocationRecord::AllocationMap::findRecord causing it to incorrectly report
  offset of ptr+size_of_allocation as found.

v0.3.4

Fixed

• Bug in AllocationMap::findRecord causing it to miss finding
  allocations that were zero bytes in length.

v0.3.3

Added

• NUMA strategy (umpire::strategy::NumaPolicy) that allows allocating memory
  an specific NUMA nodes.

• Implemented << for Allocator, so that it can be printed directly.

• Update getAllocator methods to print list of available Allocators if the
  requested Allocator cannot be found.

• Replay now captures coalesce operations from strategy::DynamicPool so that
  these can be replayed.

• The replay tool can produce an output file that can be used to verify the
  replayed events are correct.

• Cookbook example for creating a pool in pinned memory using FORTRAN.

• GitHub workflow to check for CHANGELOG updates.

• Ability to print allocation records that only match a predicate,
  print_allocator_records() to get all records from a specific
  allocator, and a cookbook recipe to do that.

• Dockerfile for multi-stage builds. Supports building Umpire with GCC, Clang,
  and CUDA

• GitHub action to run Clang static analysis.

• Replay now includes unique replay ID of the logging process to help
  distinguish processes in an multi-process run.

• Umpire replay now takes a "--help" option and displays usage information.

Changed

• Umpire now builds as a single library, libumpire.a or libumpire.so, rather
  than having one library per source subdirectory.

• Removed shared_ptr usage entirely. Ownership of objects was never "shared"
  and the smart pointers added unecessary overhead.

• Moved CHANGELOG to CHANGELOG.md.

Removed

• The 'coalesce' method was removed from ResourceManager and now must be
  accessed directory. examples/cookbook/recipe_coalesce_pool.cpp shows how to do
  this.

Fixed

• Bug in ResourceManager::copy/memset when given a pointer offset into an
  allocation.

• Memory leak in judyL2Array.

• While replay already was recording release operations, the tool was not
  actually replaying them. A fix was implemented so that the replay tool will
  now also replay any captured release operations.

• make docs used to fail, because the build was setup for Read the Docs. A fix
  was implemented so Doxygen and Sphinx can be run locally, for instance to test
  out new cookbooks.

• REPLAY previously recorded some operations with multiple print statements
  causing REPLAY output from MPI runs to become mixed between multiple ranks.
  REPLAY has been modified to output each operation onto a single line.

v0.3.2

This release contains bug fixes, an updated C interface, and some improvements to Umpire's replay capability:

• Fixed bug in Judy where an allocation may not have been correctly found.
• Add new functions to create Allocators to the C interface, and ensure all C interface files are correctly installed
• Fixed bugs in replay where some allocations were skipped, and added new tool to only replay AllocationMap operations
• Fix AllocationMap::find where it would incorrectly return a record when the allocation should not have been found

Please download the umpire-0.3.2.tar.gz file, rather than the automatically generated files. These do not include all the necessary submodule code.

v0.3.1

This release contains some improvements and fixes:

• Added a "cookbook" of examples on using Umpire in complex situations
• Allow users to provide a heuristic to modify pool behavior, determining when unused blocks will be coalesced
• Modify the CudaAdvice* operations to take a specific device id
• Improve error message when running a CUDA-enabled version of Umpire on a machine without GPUs.

v0.3.0

This release contains some new features and performance improvements.

• Umpire now supports AMD GPUs. The option ENABLE_ROCM will add support for AMD GPUs on systems that have the ROCm software stack and hcc compiler installed.
• The C/Fortran API has been updated and expanded. Further support will be coming in the next release.
• DynamicPool has a couple of performance and usability improvements: reserved but unused memory can be returned to the system using the release() function; and we have added a ResourceManager::coalesce(Allocator allocator) method that can merge unused blocks into a single allocation that will improve performance and reduce memory overhead. The coalesce method is automatically called when a DynamicPool has no active allocations.

0.2.4

This release contains several new features, bug fixes, and enhancements!

New features include:

• Support for allocating "constant" memory on CUDA GPUs
• A way of toggling introspection, to improve performance for allocators where
  you don't need tracking

Fixes and enhancements are:

• Ability to deallocate nullptr (it's a no-op)
• Fixed a bug when compiling with clang that would cause problems in the AllocationMap
• Ensure all classes with virtual functions have virtual destructors

v0.2.3

This release adds initial thread-safety to data structures and provides a ThreadSafeAllocator that can be used to make any AllocationStrategy safe when shared across multiple threads.

It also updates the AllocationAdvisor so that "HOST"-based Allocators be used as arguments when applying memory advice (such as setting "HOST" as the preferred location for data allocated in unified memory).

v0.2.2

This release adds the ability to get the actual amount of memory allocated by pools, as well as the total amount that was requested by the user. It also adds support for reallocating null pointers.