Rework host memory allocation mechanics

.gitlab/build_dane.yml

@@ -59,6 +59,13 @@ dane-gcc_13_3_1-werror-src:
     EXTRA_CMAKE_OPTIONS: "-DENABLE_WARNINGS_AS_ERRORS:BOOL=ON"
   extends: .src_build_on_dane
 
+dane-gcc_13_3_1-umpire_host_default-werror-src:
+  variables:
+    COMPILER: "gcc@13.3.1"
+    HOST_CONFIG: "dane-toss_4_x86_64_ib-${COMPILER}.cmake"
+    EXTRA_CMAKE_OPTIONS: "-DENABLE_WARNINGS_AS_ERRORS:BOOL=ON -DAXOM_DEFAULT_HOST_ALLOCATOR=UMPIRE_HOST"
+  extends: .src_build_on_dane
+
 dane-sanitizers-gcc_13_3_1-src:
   variables:
     COMPILER: "gcc@13.3.1"

RELEASE-NOTES.md

@@ -107,6 +107,10 @@ The Axom project release numbers follow [Semantic Versioning](http://semver.org/
 - Quest: Status-returning reader/writer operations in `C2CReader`, `MFEMReader`, `ProEReader`,
   `STEPReader`, `STLReader`, `STLWriter`, and their parallel variants are now marked `[[nodiscard]]`.
   Callers that previously ignored returned status values must check them to avoid compiler diagnostics.
+- Axom's host execution-space default allocator is now a configure-time policy. The default policy is malloc, regardless
+  of whether Axom is configured with Umpire enabled. Umpire builds may opt into the Umpire `HOST` resource with
+  `-DAXOM_DEFAULT_HOST_ALLOCATOR=UMPIRE_HOST`. Runtime per-use selection remains available through existing explicit
+  allocator-ID arguments.
 
 ### Fixed
 - MIR/Bump: `MergeCoordsetPoints` now only emits its node-merge `SLIC_INFO` when MIR `verbose` is enabled on the Conduit options passed through ELVIRA.

src/axom/config.hpp.in

@@ -81,6 +81,7 @@
  * Compiler defines for library capabilities
  */
 #cmakedefine AXOM_USE_UMPIRE_SHARED_MEMORY
+#cmakedefine AXOM_DEFAULT_HOST_ALLOCATOR_USES_UMPIRE_HOST
 
 /*
  * Compiler defines for third-party executables

src/axom/core/ArrayBase.hpp

@@ -911,7 +911,7 @@ struct DeviceStagingBuffer
 #if defined(AXOM_USE_CUDA) && defined(AXOM_USE_UMPIRE)
     if(m_deviceStage)
     {
-      int allocator_id = axom::detail::getAllocatorID<axom::MemorySpace::Host>();
+      int allocator_id = axom::detail::getDefaultHostAllocatorID();
       m_staging_buf = axom::allocate<T>(nelems, allocator_id);
       if(read_from_data)
       {
@@ -1018,7 +1018,7 @@ struct ArrayOps
     if constexpr(std::is_default_constructible_v<T>)
     {
 #if defined(AXOM_USE_GPU) && defined(AXOM_USE_UMPIRE)
-      if(space != MemorySpace::Host)
+      if(space != MemorySpace::Host && space != MemorySpace::Malloc)
       {
         if constexpr(std::is_trivially_default_constructible_v<T>)
         {
@@ -1062,7 +1062,7 @@ struct ArrayOps
   void fill(T* array, IndexType begin, IndexType nelems, const T& value)
   {
 #if defined(AXOM_USE_GPU) && defined(AXOM_USE_UMPIRE)
-    if(space != MemorySpace::Host)
+    if(space != MemorySpace::Host && space != MemorySpace::Malloc)
     {
       if constexpr(std::is_trivially_copyable_v<T>)
       {

src/axom/core/examples/core_array_perf.cpp

@@ -161,12 +161,10 @@ int allocatorIdFromPolicy(axom::runtime_policy::Policy policy)
 {
   AXOM_UNUSED_VAR(policy);
 #if defined(AXOM_USE_UMPIRE)
-  int allocatorID = policy == axom::runtime_policy::Policy::seq
-    ? axom::detail::getAllocatorID<axom::MemorySpace::Host>()
-    :
+  int allocatorID =
+    policy == axom::runtime_policy::Policy::seq ? axom::detail::getDefaultHostAllocatorID() :
   #if defined(AXOM_RUNTIME_POLICY_USE_OPENMP)
-    policy == axom::runtime_policy::Policy::omp
-    ? axom::detail::getAllocatorID<axom::MemorySpace::Host>()
+    policy == axom::runtime_policy::Policy::omp ? axom::detail::getDefaultHostAllocatorID()
     :
   #endif
   #if defined(AXOM_RUNTIME_POLICY_USE_CUDA)
@@ -204,12 +202,20 @@ class MDMappingPerfTester
   {
     m_allocatorId = allocatorIdFromPolicy(params.runtimePolicy);
 #ifdef AXOM_USE_UMPIRE
-    umpire::ResourceManager& rm = umpire::ResourceManager::getInstance();
-    umpire::Allocator allocator = rm.getAllocator(m_allocatorId);
-    std::cout << axom::fmt::format("Allocator id: {}, Umpire memory space {}",
-                                   m_allocatorId,
-                                   allocator.getName())
-              << std::endl;
+    if(m_allocatorId == axom::MALLOC_ALLOCATOR_ID)
+    {
+      std::cout << axom::fmt::format("Allocator id: {}, malloc memory space", m_allocatorId)
+                << std::endl;
+    }
+    else
+    {
+      umpire::ResourceManager& rm = umpire::ResourceManager::getInstance();
+      umpire::Allocator allocator = rm.getAllocator(m_allocatorId);
+      std::cout << axom::fmt::format("Allocator id: {}, Umpire memory space {}",
+                                     m_allocatorId,
+                                     allocator.getName())
+                << std::endl;
+    }
 #else
     std::cout << axom::fmt::format("Allocator id: {}, default memory space", m_allocatorId)
               << std::endl;

src/axom/core/execution/execution_space.hpp

@@ -32,7 +32,7 @@
  *    with OpenMp, i.e., RAJA_ENABLE_OPENMP must be defined in the generated
  *    RAJA/config.hpp.
  *
- *    The default memory allocator when using this execution space is HOST.
+ *    The default memory allocator when using this execution space is malloc.
  *
  *    When using this execution space, the data must reside on CPU/host memory.
  *

src/axom/core/execution/internal/omp_exec.hpp

@@ -16,11 +16,6 @@
   #error OMP_EXEC requires an OpenMP enabled RAJA
 #endif
 
-// Umpire includes
-#ifdef AXOM_USE_UMPIRE
-  #include "umpire/Umpire.hpp"
-#endif
-
 namespace axom
 {
 /*!
@@ -41,25 +36,18 @@ struct execution_space<OMP_EXEC>
   using atomic_policy = RAJA::omp_atomic;
   using sync_policy = RAJA::omp_synchronize;
 
-#ifdef AXOM_USE_UMPIRE
+#ifdef AXOM_DEFAULT_HOST_ALLOCATOR_USES_UMPIRE_HOST
   static constexpr MemorySpace memory_space = MemorySpace::Host;
 #else
-  static constexpr MemorySpace memory_space = MemorySpace::Dynamic;
+  static constexpr MemorySpace memory_space = MemorySpace::Malloc;
 #endif
 
   AXOM_HOST_DEVICE static constexpr bool async() noexcept { return false; }
   AXOM_HOST_DEVICE static constexpr bool valid() noexcept { return true; }
   AXOM_HOST_DEVICE static constexpr bool onDevice() noexcept { return false; }
   AXOM_HOST_DEVICE static constexpr char* name() noexcept { return (char*)"[OMP_EXEC]"; }
 
-  static int allocatorID() noexcept
-  {
-#ifdef AXOM_USE_UMPIRE
-    return axom::getUmpireResourceAllocatorID(umpire::resource::Host);
-#else
-    return axom::getDefaultAllocatorID();
-#endif
-  }
+  static int allocatorID() noexcept { return axom::detail::getDefaultHostAllocatorID(); }
   AXOM_HOST_DEVICE static constexpr runtime_policy::Policy runtimePolicy() noexcept
   {
     return runtime_policy::Policy::omp;

src/axom/core/execution/internal/seq_exec.hpp

@@ -14,11 +14,6 @@
   #include "RAJA/RAJA.hpp"
 #endif
 
-// Umpire includes
-#ifdef AXOM_USE_UMPIRE
-  #include "umpire/Umpire.hpp"
-#endif
-
 namespace axom
 {
 /*!
@@ -51,25 +46,18 @@ struct execution_space<SEQ_EXEC>
 
   using sync_policy = void;
 
-#ifdef AXOM_USE_UMPIRE
+#ifdef AXOM_DEFAULT_HOST_ALLOCATOR_USES_UMPIRE_HOST
   static constexpr MemorySpace memory_space = MemorySpace::Host;
 #else
-  static constexpr MemorySpace memory_space = MemorySpace::Dynamic;
+  static constexpr MemorySpace memory_space = MemorySpace::Malloc;
 #endif
 
   AXOM_HOST_DEVICE static constexpr bool async() noexcept { return false; }
   AXOM_HOST_DEVICE static constexpr bool valid() noexcept { return true; }
   AXOM_HOST_DEVICE static constexpr bool onDevice() noexcept { return false; }
   AXOM_HOST_DEVICE static constexpr char* name() noexcept { return (char*)"[SEQ_EXEC]"; }
 
-  static int allocatorID() noexcept
-  {
-#ifdef AXOM_USE_UMPIRE
-    return axom::getUmpireResourceAllocatorID(umpire::resource::Host);
-#else
-    return axom::getDefaultAllocatorID();
-#endif
-  }
+  static int allocatorID() noexcept { return axom::detail::getDefaultHostAllocatorID(); }
   AXOM_HOST_DEVICE static constexpr runtime_policy::Policy runtimePolicy() noexcept
   {
     return runtime_policy::Policy::seq;

src/axom/core/memory_management.hpp

@@ -157,15 +157,24 @@ inline void setDefaultAllocator(umpire::resource::MemoryResourceType resource_ty
 #endif
 
 /*!
- * \brief Sets the default memory allocator to use.
- * \param [in] allocId the Umpire allocator id
+ * \brief Sets the default memory allocator for the Umpire ResourceManager. 
+ * \param [in] allocId the Axom allocator id
  * 
+ * \note When Axom is compiled with Umpire and \a allocId is
+ *       axom::MALLOC_ALLOCATOR_ID, this function sets Umpire's default
+ *       allocator to its Host resource.
  * \note This function has no effect when Axom is not compiled with Umpire.
  */
 inline void setDefaultAllocator(int allocId)
 {
 #ifdef AXOM_USE_UMPIRE
   umpire::ResourceManager& rm = umpire::ResourceManager::getInstance();
+  if(allocId == MALLOC_ALLOCATOR_ID)
+  {
+    rm.setDefaultAllocator(rm.getAllocator(umpire::resource::Host));
+    return;
+  }
+
   umpire::Allocator allocator = rm.getAllocator(allocId);
   rm.setDefaultAllocator(allocator);
 #else
@@ -188,6 +197,27 @@ inline int getDefaultAllocatorID()
 #endif
 }
 
+namespace detail
+{
+/*!
+ * \brief Returns the ID of the default host allocator.
+ *
+ * \note This is distinct from the current default allocator returned by
+ *       axom::getDefaultAllocatorID(), which tracks Umpire's default allocator
+ *       when Axom is configured with Umpire.
+ *
+ * \return ID of the default host allocator.
+ */
+inline int getDefaultHostAllocatorID()
+{
+#if defined(AXOM_DEFAULT_HOST_ALLOCATOR_USES_UMPIRE_HOST)
+  return getUmpireResourceAllocatorID(umpire::resource::Host);
+#else
+  return MALLOC_ALLOCATOR_ID;
+#endif
+}
+}  // namespace detail
+
 /*!
  * \brief Get the allocator id from which data has been allocated.
  * \return Allocator id.  If Umpire doesn't have an allocator for the
@@ -241,7 +271,7 @@ int getSharedMemoryAllocatorID(std::size_t minSegmentSize = 0);
  * \brief Allocates a chunk of memory of type T.
  *
  * \param [in] n the number of elements to allocate.
- * \param [in] allocID the Umpire allocator to use (optional)
+ * \param [in] allocID the Axom/Umpire allocator to use (optional)
  *
  * \tparam T the type of pointer returned.
  *
@@ -260,7 +290,7 @@ inline T* allocate(std::size_t n, int allocID = getDefaultAllocatorID()) noexcep
  *
  * \param [in] n the number of elements to allocate.
  * \param [in] name allocation name (must be non-empty for shared memory allocators)
- * \param [in] allocID the Umpire allocator to use (optional)
+ * \param [in] allocID the Axom/Umpire allocator to use (optional)
  *
  * \return pointer to the new allocation or a nullptr if allocation failed.
  */
@@ -360,6 +390,11 @@ inline T* allocate(std::size_t n, int allocID) noexcept
 {
   const std::size_t numbytes = n * sizeof(T);
 
+  if(allocID == MALLOC_ALLOCATOR_ID)
+  {
+    return static_cast<T*>(std::malloc(numbytes));
+  }
+
 #ifdef AXOM_USE_UMPIRE
   if(umpire::ResourceManager& rm = umpire::ResourceManager::getInstance(); rm.isAllocator(allocID))
   {
@@ -368,11 +403,6 @@ inline T* allocate(std::size_t n, int allocID) noexcept
   }
 #endif
 
-  if(allocID == MALLOC_ALLOCATOR_ID)
-  {
-    return static_cast<T*>(std::malloc(numbytes));
-  }
-
   std::cerr << "Unrecognized allocator id " << allocID << std::endl;
   axom::utilities::processAbort();
 
@@ -384,6 +414,12 @@ inline T* allocate(std::size_t n, const std::string& name, int allocID) noexcept
 {
   const std::size_t numbytes = n * sizeof(T);
 
+  if(allocID == MALLOC_ALLOCATOR_ID)
+  {
+    AXOM_UNUSED_VAR(name);
+    return static_cast<T*>(std::malloc(numbytes));
+  }
+
 #ifdef AXOM_USE_UMPIRE
   if(umpire::ResourceManager& rm = umpire::ResourceManager::getInstance(); rm.isAllocator(allocID))
   {
@@ -393,12 +429,6 @@ inline T* allocate(std::size_t n, const std::string& name, int allocID) noexcept
   }
 #endif
 
-  if(allocID == MALLOC_ALLOCATOR_ID)
-  {
-    AXOM_UNUSED_VAR(name);
-    return static_cast<T*>(std::malloc(numbytes));
-  }
-
   std::cerr << "Unrecognized allocator id " << allocID << std::endl;
   axom::utilities::processAbort();
 
@@ -547,13 +577,12 @@ inline void fill(void* dst, std::size_t n, const T& value) noexcept
       doHostFill = false;
 
       // Device memory: fill on host, then copy to device
-      const auto num_bytes = n * sizeof(T);
-      T* src = allocate<T>(num_bytes, rm.getDefaultAllocator().getId());
+      T* src = allocate<T>(n, axom::detail::getDefaultHostAllocatorID());
       for(std::size_t i = 0; i < n; ++i)
       {
         src[i] = value;
       }
-      rm.copy(dst, src, num_bytes);
+      axom::copy(dst, src, n * sizeof(T));
       deallocate<T>(src);
     }
   }

src/axom/core/tests/core_execution_space.hpp

@@ -118,6 +118,30 @@ TEST(core_execution_space, check_invalid)
   check_invalid<InvalidSpace>();
 }
 
+//------------------------------------------------------------------------------
+TEST(core_execution_space, check_default_host_allocator)
+{
+  int expected_host_allocator = axom::MALLOC_ALLOCATOR_ID;
+  auto expected_host_memory_space = axom::MemorySpace::Malloc;
+#if defined(AXOM_DEFAULT_HOST_ALLOCATOR_USES_UMPIRE_HOST)
+  expected_host_allocator = axom::getUmpireResourceAllocatorID(umpire::resource::Host);
+  expected_host_memory_space = axom::MemorySpace::Host;
+#endif
+
+  EXPECT_EQ(expected_host_memory_space, axom::execution_space<axom::SEQ_EXEC>::memory_space);
+  EXPECT_EQ(expected_host_allocator, axom::execution_space<axom::SEQ_EXEC>::allocatorID());
+
+#if defined(AXOM_USE_UMPIRE)
+  EXPECT_EQ(axom::getUmpireResourceAllocatorID(umpire::resource::Host),
+            axom::detail::getAllocatorID<axom::MemorySpace::Host>());
+#endif
+
+#if defined(AXOM_USE_OPENMP) && defined(AXOM_USE_RAJA)
+  EXPECT_EQ(expected_host_allocator, axom::execution_space<axom::OMP_EXEC>::allocatorID());
+  EXPECT_EQ(expected_host_memory_space, axom::execution_space<axom::OMP_EXEC>::memory_space);
+#endif
+}
+
 //==============================================================================
 // The following tests require RAJA and UMPIRE
 //==============================================================================
@@ -130,7 +154,7 @@ TEST(core_execution_space, check_seq_exec)
   constexpr bool IS_ASYNC = false;
   constexpr bool ON_DEVICE = false;
 
-  int allocator_id = axom::getUmpireResourceAllocatorID(umpire::resource::Host);
+  int allocator_id = axom::execution_space<axom::SEQ_EXEC>::allocatorID();
   check_execution_mappings<axom::SEQ_EXEC,
   #if RAJA_VERSION_MAJOR > 2022
                            RAJA::seq_exec,
@@ -153,7 +177,7 @@ TEST(core_execution_space, check_omp_exec)
   constexpr bool IS_ASYNC = false;
   constexpr bool ON_DEVICE = false;
 
-  int allocator_id = axom::getUmpireResourceAllocatorID(umpire::resource::Host);
+  int allocator_id = axom::execution_space<axom::OMP_EXEC>::allocatorID();
   check_execution_mappings<axom::OMP_EXEC,
                            RAJA::omp_parallel_for_exec,
                            RAJA::omp_reduce,