LLNL · BradWhitlock · Oct 22, 2025 · Sep 5, 2025 · Sep 5, 2025 · Sep 6, 2025
diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md
@@ -110,6 +110,9 @@ The Axom project release numbers follow [Semantic Versioning](http://semver.org/
   arrays of query points
 - Core: Updates behavior of `FlatMap::reserve()` to only trigger a rehash if maximum load factor
   would be exceeded.
+- Quest: The signed_distance functions were modified so they use Umpire's shared memory mechanisms instead of using MPI3 directly.
+- Axom's `AXOM_USE_MPI3` CMake build option and corresponding macro definition were removed.
+- When Umpire is present, Axom now detects whether it supports shared memory and defines the `AXOM_USE_UMPIRE_SHARED_MEMORY` macro if appropriate. This macro can be used to conditionally compile code involving shared memory via Umpire.
 - Quest: Moves curve linearization from the `quest::C2CReader` into `quest::LinearizeCurves` so the logic can be used with other curve data.
 
 ###  Fixed

diff --git a/scripts/spack/packages/axom/package.py b/scripts/spack/packages/axom/package.py
@@ -157,6 +157,7 @@ class Axom(CachedCMakePackage, CudaPackage, ROCmPackage):
         depends_on("[email protected]", when="@0.6.0")
         depends_on("umpire@5:5.0.1", when="@:0.5.0")
         depends_on("umpire+openmp", when="+openmp")
+        depends_on("umpire+mpi3_shmem", when="+mpi")
 
     with when("+raja"):
         depends_on("raja")

diff --git a/src/axom/config.hpp.in b/src/axom/config.hpp.in
@@ -54,7 +54,6 @@
 #cmakedefine AXOM_USE_CUDA
 #cmakedefine AXOM_USE_HIP
 #cmakedefine AXOM_USE_MPI
-#cmakedefine AXOM_USE_MPI3
 #cmakedefine AXOM_USE_MPIF_HEADER
 #cmakedefine AXOM_USE_OPENMP
 
@@ -77,6 +76,11 @@
 #cmakedefine AXOM_USE_SPARSEHASH
 #cmakedefine AXOM_USE_UMPIRE
 
+/*
+ * Compiler defines for library capabilities
+ */
+#cmakedefine AXOM_USE_UMPIRE_SHARED_MEMORY
+
 /*
  * Compiler defines for third-party executables
  */

diff --git a/src/axom/core/CMakeLists.txt b/src/axom/core/CMakeLists.txt
@@ -107,6 +107,7 @@ set(core_sources
 
     numerics/polynomial_solvers.cpp
 
+    memory_management.cpp
     Path.cpp
     Types.cpp
     )

diff --git a/src/axom/core/memory_management.cpp b/src/axom/core/memory_management.cpp
@@ -0,0 +1,61 @@
+// Copyright (c) 2017-2025, Lawrence Livermore National Security, LLC and
+// other Axom Project Developers. See the top-level LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+
+#include "axom/core/memory_management.hpp"
+
+#if defined(AXOM_USE_UMPIRE)
+  #include "axom/fmt.hpp"
+  #include "umpire/Umpire.hpp"
+  #include "umpire/util/MemoryResourceTraits.hpp"
+  #if defined(AXOM_USE_UMPIRE_SHARED_MEMORY)
+    #include "umpire/strategy/NamedAllocationStrategy.hpp"
+  #endif
+#endif
+
+namespace axom
+{
+
+bool isSharedMemoryAllocator(int allocID)
+{
+  bool isShared = false;
+#if defined(AXOM_USE_UMPIRE)
+  umpire::ResourceManager& rm = umpire::ResourceManager::getInstance();
+  if(rm.isAllocator(allocID))
+  {
+    umpire::Allocator allocator = rm.getAllocator(allocID);
+
+    isShared = allocator.getAllocationStrategy()->getTraits().resource ==
+      umpire::MemoryResourceTraits::resource_type::shared;
+  }
+#endif
+  return isShared;
+}
+
+int getSharedMemoryAllocatorID()
+{
+  int allocator_id = INVALID_ALLOCATOR_ID;
+#if defined(AXOM_USE_UMPIRE_SHARED_MEMORY)
+  const std::string allocatorName("axom_shared_allocator");
+  auto& rm = umpire::ResourceManager::getInstance();
+  if(!rm.isAllocator(allocatorName))
+  {
+    // Create the allocator
+    const auto name = axom::fmt::format("SHARED::{}", UMPIRE_DEFAULT_SHARED_MEMORY_RESOURCE);
+    auto traits {umpire::get_default_resource_traits(name)};
+    traits.scope = umpire::MemoryResourceTraits::shared_scope::node;
+    auto axom_node_allocator {rm.makeResource(axom::fmt::format("{}::axom_node_allocator", name), traits)};
+    auto axom_shared_allocator {
+      rm.makeAllocator<umpire::strategy::NamedAllocationStrategy>(allocatorName, axom_node_allocator)};
+    allocator_id = axom_shared_allocator.getId();
+  }
+  else
+  {
+    allocator_id = rm.getAllocator(allocatorName).getId();
+  }
+#endif
+  return allocator_id;
+}
+
+}  // end namespace axom
diff --git a/src/axom/core/memory_management.hpp b/src/axom/core/memory_management.hpp
@@ -144,6 +144,23 @@ inline int getAllocatorIDFromPointer(const void* ptr)
   return ptr == nullptr ? INVALID_ALLOCATOR_ID : MALLOC_ALLOCATOR_ID;
 }
 
+/*!
+ * \brief Determines whether an allocator id is for shared memory.
+ *
+ * \param allocID An allocator id.
+ *
+ * \return True if the allocator id is for shared memory; false otherwise.
+ */
+bool isSharedMemoryAllocator(int allocID);
+
+/*!
+ * \brief Get the allocator ID for Axom's shared memory allocator.
+ *
+ * \return The allocator ID for Axom's shared memory allocator (if Axom is using Umpire),
+ *         or INVALID_ALLOCATOR_ID otherwise.
+ */
+int getSharedMemoryAllocatorID();
+
 /*!
  * \brief Allocates a chunk of memory of type T.
  *

diff --git a/src/axom/core/tests/CMakeLists.txt b/src/axom/core/tests/CMakeLists.txt
@@ -104,6 +104,7 @@ axom_add_test( NAME    core_collections
 if (AXOM_ENABLE_MPI)
   set( core_mpi_tests
        core_types.hpp
+       core_shared_memory.hpp
        )
 
   axom_add_executable(NAME       core_mpi_tests
@@ -117,7 +118,7 @@ if (AXOM_ENABLE_MPI)
     get_filename_component( test_suite ${test_suite} NAME_WE )
     axom_add_test( NAME          ${test_suite}_mpi
                    COMMAND       core_mpi_tests --gtest_filter=${test_suite}*
-                   NUM_MPI_TASKS 1 )
+                   NUM_MPI_TASKS 2 )
   endforeach()
 endif()
 

diff --git a/src/axom/core/tests/core_mpi_main.cpp b/src/axom/core/tests/core_mpi_main.cpp
@@ -10,6 +10,7 @@
 #include "axom/config.hpp"
 
 #include "core_types.hpp"
+#include "core_shared_memory.hpp"
 
 int main(int argc, char* argv[])
 {

diff --git a/src/axom/core/tests/core_shared_memory.hpp b/src/axom/core/tests/core_shared_memory.hpp
@@ -0,0 +1,54 @@
+// Copyright (c) 2017-2025, Lawrence Livermore National Security, LLC and
+// other Axom Project Developers. See the top-level LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+
+// Axom includes
+#include "axom/config.hpp"
+#include "axom/core/memory_management.hpp"
+
+// gtest includes
+#include "gtest/gtest.h"
+
+#include <mpi.h>
+
+//------------------------------------------------------------------------------
+#if defined(AXOM_USE_UMPIRE_SHARED_MEMORY)
+TEST(core_shared_memory, shared_memory_allocator)
+{
+  EXPECT_FALSE(axom::isSharedMemoryAllocator(axom::getDefaultAllocatorID()));
+  EXPECT_TRUE(axom::isSharedMemoryAllocator(axom::getSharedMemoryAllocatorID()));
+
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  const int sizes[] = {1024, 4096, 1000000};
+  for(int si = 0; si < 3; si++)
+  {
+    // Allocate shared memory
+    const int N = sizes[si];
+    int *buffer = axom::allocate<int>(N, axom::getSharedMemoryAllocatorID());
+
+    // Populate the shared memory on rank 0
+    if(rank == 0)
+    {
+      for(int i = 0; i < N; i++)
+      {
+        buffer[i] = i;
+      }
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    // Test the shared memory on all ranks.
+    for(int i = 0; i < N; i++)
+    {
+      EXPECT_EQ(buffer[i], i);
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    axom::deallocate(buffer);
+  }
+}
+#endif