v1.1.0

This release contains the following major changes:

• Added symbol umpire_ver_1_detected to help detect version mismatches when
  linking multiple libraries that all use Umpire.

• Re-introduced pool algorithm used in pre-1.0.0 releases as DynamicPoolList,
  and renamed current strategy to DynamicPoolMap. DynamicPool is now an
  alias to DynamicPoolMap.

• Fix signature of C function umpire_resourcemanager_make_allocator_pool to
  take size_t not int.

Please download the umpire-1.1.0.tar.gz file, rather than the files generated automatically by Github, as these do not include all the necessary submodule code.

v1.0.1

This release fixes a bug in the DynamicPool where blocks would be leaked if a minimum size block was allocated for a smaller allocation in certain circumstances.

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