Draft: Add experimental implementation of CHAI using the strategy pattern

cmake/SetupChaiOptions.cmake

@@ -20,6 +20,7 @@ option(CHAI_ENABLE_MANAGED_PTR "Enable managed_ptr" On)
 option(CHAI_DEBUG "Enable Debug Logging." Off)
 option(CHAI_ENABLE_RAJA_NESTED_TEST "Enable raja-chai-nested-tests, which fails to build on Debug CUDA builds." On)
 option(CHAI_ENABLE_MANAGED_PTR_ON_GPU "Enable managed_ptr on GPU" On)
+option(CHAI_ENABLE_EXPERIMENTAL "Enable experimental features" On)
 
 option(CHAI_ENABLE_TESTS "Enable CHAI tests" On)
 option(CHAI_ENABLE_BENCHMARKS "Enable benchmarks" Off)

host-configs/lc/blueos_3_ppc64le_ib_p9/nvcc_clang.cmake

@@ -30,3 +30,5 @@ set(CMAKE_CUDA_COMPILER "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc" CACHE PATH "")
 set(CMAKE_CUDA_HOST_COMPILER "${CMAKE_CXX_COMPILER}" CACHE PATH "")
 set(CMAKE_CUDA_ARCHITECTURES "70" CACHE STRING "")
 set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=--gcc-toolchain=${GCC_HOME}" CACHE STRING "")
+
+set(UMPIRE_FMT_TARGET "fmt::fmt" CACHE STRING "")

host-configs/lc/toss_4_x86_64_ib_cray/amdclang.cmake

@@ -6,8 +6,8 @@
 ##############################################################################
 
 # Set up software versions
-set(ROCM_VERSION "6.2.0" CACHE PATH "")
-set(GCC_VERSION "12.2.1" CACHE PATH "")
+set(ROCM_VERSION "6.4.1" CACHE PATH "")
+set(GCC_VERSION "13.3.1" CACHE PATH "")
 
 # Set up compilers
 set(COMPILER_BASE "/usr/tce/packages/rocmcc/rocmcc-${ROCM_VERSION}-magic" CACHE PATH "")

src/chai/CMakeLists.txt

@@ -22,6 +22,13 @@ set (chai_headers
   PointerRecord.hpp
   Types.hpp)
 
+if(CHAI_ENABLE_EXPERIMENTAL)
+  set(chai_headers
+      ${chai_headers}
+      expt/ExecutionContext.hpp
+      expt/ExecutionContextManager.hpp)
+endif()
+
 if(CHAI_DISABLE_RM)
   set(chai_headers
     ${chai_headers}

src/chai/expt/Allocator.hpp

@@ -0,0 +1,77 @@
+#ifndef CHAI_ALLOCATOR_HPP
+#define CHAI_ALLOCATOR_HPP
+
+namespace chai::expt {
+  class Allocator {
+    private:
+      class AllocatorConcept
+      {
+        public:
+          virtual ~AllocatorConcept() = default;
+          virtual void* do_allocate(std::size_t bytes) = 0;
+          virtual void do_deallocate(void* ptr) = 0;
+          virtual std::unique_ptr<AllocatorConcept> clone() const = 0;
+      };  // class AllocatorConcept
+
+      template <typename AllocatorType>
+      class AllocatorModel : public AllocatorConcept
+      {
+        public:
+          AllocatorModel(AllocatorType allocator)
+            : m_allocator{std::move(allocator)}
+          {
+          }
+
+          virtual void* allocate(std::size_t bytes) override
+          {
+            return allocate(m_allocator, bytes);
+          }
+
+          virtual void do_deallocate(void* ptr) override
+          {
+            deallocate(m_allocator, ptr);
+          }
+
+          virtual std::unique_ptr<AllocatorConcept> clone() const override
+          {
+            return std::make_unique<AllocatorModel>(*this);
+          }
+
+        private:
+          AllocatorType m_allocator;
+      };  // class AllocatorModel
+
+      friend void* allocate(const Allocator& allocator, std::size_t bytes)
+      {
+        return allocator.m_pimpl->do_allocate(bytes);
+      }
+
+      friend void deallocate(const Allocator& allocator, void* ptr)
+      {
+        allocator.m_pimple->do_deallocate(ptr);
+      }
+
+      std::unique_ptr<AllocatorConcept> m_pimpl;
+
+    public:
+      template <typename AllocatorType>
+      Allocator(AllocatorType allocator)
+        : m_pimpl{std::make_unique<AllocatorModel<AllocatorType>>(std::move(allocator))}
+      {
+      }
+
+      Allocator(const Allocator& other)
+        : m_pimple{other.m_pimpl->clone()}
+      { 
+      }
+
+      Allocator& operator=(const Allocator& other)
+      {
+        Allocator temp(other);
+        std::swap(m_pimpl, temp.m_pimpl);
+        return *this;
+      }
+  };  // class Allocator
+}
+
+#endif  // CHAI_ALLOCATOR_HPP

src/chai/expt/Array.hpp

@@ -0,0 +1,275 @@
+#ifndef CHAI_MANAGED_ARRAY_HPP
+#define CHAI_MANAGED_ARRAY_HPP
+
+#include "chai/expt/ArrayManager.hpp"
+#include "chai/expt/ExecutionContextManager.hpp"
+#include <cstddef>
+
+namespace chai {
+namespace expt {
+  /*!
+   * \class ManagedArray
+   *
+   * \brief An array class that manages coherency across the CPU and GPU.
+   *        How the coherence is obtained is controlled by the array manager.
+   *
+   * \tparam ElementType The type of element in the array.
+   */
+  template <typename ElementType>
+  class ManagedArray {
+    public:
+      /*!
+       * \brief Constructs an empty array without an array manager.
+       */
+      ManagedArray() = default;
+
+      /*!
+       * \brief Constructs an array from a manager.
+       *
+       * \param manager The array manager controls the coherence of the array.
+       *
+       * \note The array takes ownership of the manager.
+       */
+      explicit ManagedArray(ArrayManager<ElementType>* manager)
+        : m_manager{manager}
+      {
+        if (m_manager)
+        {
+          m_size = m_manager->size();
+        }
+      }
+
+      /*!
+       * \brief Constructs a shallow copy of an array from another and makes
+       *        the data coherent in the current execution space.
+       *
+       * \param other The other array.
+       *
+       * \note This is a shallow copy.
+       */
+      CHAI_HOST_DEVICE ManagedArray(const ManagedArray& other) :
+        m_data{other.m_data},
+        m_size{other.m_size},
+        m_manager{other.m_manager}
+      {
+#if !defined(CHAI_DEVICE_COMPILE)
+        if (m_manager) {
+          m_data = m_manager->data(!std::is_const<ElementType>::value));
+        }
+#endif
+      }
+
+      /*!
+       * \brief Constructs a ManagedArray<const T> from a ManagedArray<T>.
+       *
+       * \param other The non-const array to convert from.
+       *
+       * \note This is a converting constructor that enables implicit conversion
+       *       from ManagedArray<T> to ManagedArray<const T>.
+       */
+      template <typename OtherElementType, 
+                std::enable_if_t<std::is_convertible_v<OtherElementType (*)[], ElementType (*)[]>* = nullptr>
+      CHAI_HOST_DEVICE ManagedArray(const ManagedArray<OtherElementType>& other)
+        : m_data{other.m_data},
+          m_size{other.m_size},
+          m_manager{other.m_manager}
+      {
+      }
+
+      /*!
+       * \brief Sets the array manager for this ManagedArray.
+       *
+       * \param manager The new array manager to be set.
+       *
+       * \post The ManagedArray takes ownership of the new manager objet.
+       */
+       void setManager(ArrayManager<ElementType>* manager)
+       {
+         delete m_manager;
+         m_manager = manager;
+       }
+
+      /*!
+       * \brief Get the array manager associated with this ManagedArray.
+       *
+       * \return A pointer to the array manager.
+       */
+      ArrayManager<ElementType>* getManager() const {
+        return m_manager;
+      }
+
+      /*!
+       * \brief Resizes the array to the specified new size.
+       *
+       * \param newSize The new size to resize the array to.
+       *
+       * \note This method updates the size of the array and triggers a resize operation in the array manager if it exists.
+       *       If no array manager is associated, an exception is thrown.
+       */
+      void resize(std::size_t newSize) {
+        if (m_manager) {
+          m_size = newSize;
+          m_manager->resize(newSize);
+        }
+        else {
+          throw std::runtime_exception("Unable to resize");
+        }
+      }
+
+      /*!
+       * \brief Frees the resources associated with this array.
+       *
+       * \note Once free has been called, it is invalid to use any other copies
+       *       of this array (since copies are shallow).
+       */
+      void free() {
+        m_data = nullptr;
+        m_size = 0;
+        delete m_manager;
+        m_manager = nullptr;
+      }
+
+      /*!
+       * \brief Get the number of elements in the array.
+       *
+       * \pre The copy constructor has been called with the execution space
+       *      set to CPU or GPU (e.g. by the RAJA plugin).
+       */
+      CHAI_HOST_DEVICE std::size_t size() const {
+        return m_size;
+      }
+
+      /*!
+       * \brief Get a pointer to the element data in the specified context.
+       *
+       * \param context The context in which to retrieve the element data.
+       *
+       * \return A pointer to the element data in the specified context.
+       */
+      ElementType* data(ExecutionContext context) const {
+        if (m_manager) {
+          m_data = m_manager->data(context, !std::is_const<ElementType>::value);
+        }
+
+        return m_data;
+      }
+
+      /*!
+       * \brief Get a const pointer to the element data in the specified context.
+       *
+       * \param context The context in which to retrieve the const element data.
+       *
+       * \return A const pointer to the element data in the specified context.
+       */
+      const ElementType* cdata(ExecutionContext context) const {
+        if (m_manager) {
+          m_data = m_manager->data(context, false);
+        }
+
+        return m_data;
+      }
+
+      /*!
+       * \brief Get a pointer to the element data in the current execution space.
+       *
+       * \return A pointer to the element data in the current execution space.
+       */
+      CHAI_HOST_DEVICE ElementType* data() const {
+#if !defined(CHAI_DEVICE_COMPILE)
+        return data(HOST);
+#endif
+        return m_data;
+      }
+
+      /*!
+       * \brief Get a const pointer to the element data in the current execution space.
+       *
+       * \return A const pointer to the element data in the current execution space.
+       */
+      CHAI_HOST_DEVICE const ElementType* cdata() const {
+#if !defined(CHAI_DEVICE_COMPILE)
+        return cdata(HOST);
+#endif
+        return m_data;
+      }
+
+      /*!
+       * \brief Get the ith element in the array.
+       *
+       * \param i The index of the element to retrieve.
+       *
+       * \pre The copy constructor has been called with the execution space
+       *      set to CPU or GPU (e.g. by the RAJA plugin).
+       */
+      CHAI_HOST_DEVICE ElementType& operator[](std::size_t i) const {
+        return m_data[i];
+      }
+
+      /*!
+       * \brief Get the value of the element at the specified index.
+       *
+       * \param i The index of the element to retrieve.
+       *
+       * \return The value of the element at the specified index.
+       *
+       * \throw std::runtime_exception if unable to retrieve the element.
+       */
+      ElementType get(std::size_t i) const {
+        if (m_manager) {
+          return m_manager->get(i);
+        }
+        else {
+          throw std::runtime_exception("Unable to get element");
+        }
+      }
+
+      /*!
+       * \brief Set a value at a specified index in the array.
+       *
+       * \param i The index where the value is to be set.
+       * \param value The value to set at the specified index.
+       *
+       * \throw std::runtime_exception if the array manager is not associated with the ManagedArray.
+       */
+      void set(std::size_t i, const ElementType& value) {
+        if (m_manager) {
+          m_manager->set(i, value);
+        }
+        else {
+          throw std::runtime_exception("Unable to set element");
+        }
+      }
+
+    private:
+      /*!
+       * The array that is coherent in the current execution space.
+       */
+      ElementType* m_data = nullptr;
+
+      /*!
+       * The number of elements in the array.
+       */
+      std::size_t m_size = 0;
+
+      /*!
+       * The array manager controls the coherence of the array.
+       */
+      ArrayManager<ElementType>* m_manager = nullptr;
+  };  // class ManagedArray
+
+  /*!
+   * \brief Constructs an array by creating a new manager object.
+   *
+   * \tparam ArrayManager<ElementType> The type of array manager.
+   * \tparam Args The type of the arguments used to construct the array manager.
+   *
+   * \param args The arguments to construct an array manager.
+   */
+  template <typename ElementType, typename ArrayManager<ElementType>, typename... Args>
+  ManagedArray<ElementType> makeArray(Args&&... args) {
+    return ManagedArray<ElementType>(new ArrayManager<ElementType>(std::forward<Args>(args)...));
+  }
+}  // namespace expt
+}  // namespace chai
+
+#endif  // CHAI_MANAGED_ARRAY_HPP