Initial MIR component

config-build.py

@@ -84,6 +84,10 @@ def parse_arguments():
         help="Create an eclipse project file.",
     )
 
+    parser.add_argument(
+        "-n", "--ninja", action="store_true", help="Create a Ninja project."
+    )
+
     parser.add_argument(
         "-x", "--xcode", action="store_true", help="Create an xcode project."
     )
@@ -270,6 +274,9 @@ def create_cmake_command_line(
     if args.eclipse:
         cmakeline += ' -G "Eclipse CDT4 - Unix Makefiles"'
 
+    if args.ninja:
+        cmakeline += ' -G "Ninja"'
+
     if args.xcode:
         cmakeline += ' -G "Xcode"'
 

src/axom/CMakeLists.txt

@@ -38,6 +38,15 @@ axom_add_component(COMPONENT_NAME klee   DEFAULT_STATE ${AXOM_ENABLE_ALL_COMPONE
 axom_add_component(COMPONENT_NAME quest  DEFAULT_STATE ${AXOM_ENABLE_ALL_COMPONENTS})
 axom_add_component(COMPONENT_NAME multimat DEFAULT_STATE ${AXOM_ENABLE_ALL_COMPONENTS})
 
+# Add MIR if the prerequisites are found.
+if(RAJA_FOUND AND UMPIRE_FOUND AND CONDUIT_FOUND)
+    axom_add_component(COMPONENT_NAME mir
+                       DEFAULT_STATE  ${AXOM_ENABLE_ALL_COMPONENTS})
+else()
+    message(STATUS "Axom Component MIR turned off due to missing RAJA, UMPIRE, or Conduit.")
+    set(AXOM_ENABLE_MIR OFF CACHE BOOL "")
+endif()
+
 install(TARGETS              ${AXOM_COMPONENTS_ENABLED}
         EXPORT               axom-targets
         DESTINATION          lib)

src/axom/config.hpp.in

@@ -99,6 +99,7 @@
 #cmakedefine AXOM_USE_KLEE
 #cmakedefine AXOM_USE_LUMBERJACK
 #cmakedefine AXOM_USE_MINT
+#cmakedefine AXOM_USE_MIR
 #cmakedefine AXOM_USE_PRIMAL
 #cmakedefine AXOM_USE_QUEST
 #cmakedefine AXOM_USE_SIDRE

src/axom/core/ArrayView.hpp

@@ -73,7 +73,7 @@ class ArrayView : public ArrayBase<T, DIM, ArrayView<T, DIM, SPACE>>
     typename... Args,
     typename Enable = typename std::enable_if<
       sizeof...(Args) == DIM && detail::all_types_are_integral<Args...>::value>::type>
-  ArrayView(T* data, Args... args);
+  AXOM_HOST_DEVICE ArrayView(T* data, Args... args);
 
   /*!
    * \brief Generic constructor for an ArrayView of arbitrary dimension with external data
@@ -232,7 +232,7 @@ using MCArrayView = ArrayView<T, 2>;
 //------------------------------------------------------------------------------
 template <typename T, int DIM, MemorySpace SPACE>
 template <typename... Args, typename Enable>
-ArrayView<T, DIM, SPACE>::ArrayView(T* data, Args... args)
+AXOM_HOST_DEVICE ArrayView<T, DIM, SPACE>::ArrayView(T* data, Args... args)
   : ArrayView(data,
               StackArray<IndexType, DIM> {{static_cast<IndexType>(args)...}})
 {

src/axom/core/CMakeLists.txt

@@ -27,6 +27,7 @@ set(core_headers
     utilities/CommandLineUtilities.hpp
     utilities/FileUtilities.hpp
     utilities/RAII.hpp
+    utilities/Sorting.hpp
     utilities/StringUtilities.hpp
     utilities/System.hpp
     utilities/Timer.hpp
@@ -73,6 +74,7 @@ set(core_headers
     execution/for_all.hpp
     execution/nested_for_exec.hpp
     execution/runtime_policy.hpp
+    execution/scans.hpp
     execution/synchronize.hpp
 
     execution/internal/seq_exec.hpp

src/axom/core/StackArray.hpp

@@ -10,6 +10,8 @@
 #include "axom/core/Macros.hpp"  // for axom macros
 #include "axom/core/Types.hpp"   // for axom types
 
+#include <iostream>
+
 namespace axom
 {
 /*!
@@ -27,6 +29,14 @@ namespace axom
 template <typename T, int N>
 struct StackArray
 {
+  using value_type = T;
+
+  /*!
+   * \brief Return size of the array.
+   */
+  AXOM_HOST_DEVICE
+  constexpr static int size() { return N; }
+
   /*!
    * \brief Accessor, returns a reference to the value at the given index.
    *
@@ -55,6 +65,9 @@ struct StackArray
   AXOM_HOST_DEVICE
   constexpr operator const T*() const noexcept { return &m_data[0]; }
 
+  AXOM_HOST_DEVICE T* data() noexcept { return &m_data[0]; }
+  AXOM_HOST_DEVICE const T* data() const noexcept { return &m_data[0]; }
+
   /// @}
 
   /*!
@@ -135,6 +148,28 @@ AXOM_HOST_DEVICE bool operator<(const StackArray<T, N>& lhs,
   return false;
 }
 
+/**
+ * \brief Print the StackArray to a stream.
+ * \param os The stream to use.
+ * \param obj The StackArray to print.
+ * \return The input stream.
+ */
+template <typename T, int N>
+std::ostream& operator<<(std::ostream& os, const StackArray<T, N>& obj)
+{
+  os << "(";
+  for(int i = 0; i < N; i++)
+  {
+    if(i > 0)
+    {
+      os << ", ";
+    }
+    os << obj.m_data[i];
+  }
+  os << ")";
+  return os;
+}
+
 } /* namespace axom */
 
 #endif /* AXOM_STACKARRAY_HPP_ */

src/axom/core/StaticArray.hpp

@@ -16,7 +16,8 @@ namespace axom
  * \accelerated
  * \class StaticArray
  *
- * \brief Provides a wrapper for a StackArray with an additional size member.
+ * \brief This class extends StackArray with some std::vector-like convenience methods.
+ *
  *
  * \tparam T the type of the values to hold.
  * \tparam N the number of values in the array.
@@ -25,14 +26,27 @@ namespace axom
  *       execution.
  */
 template <typename T, int N>
-struct StaticArray : public StackArray<T, N>
+class StaticArray : public StackArray<T, N>
 {
+public:
+  /*!
+   * \brief Returns the capacity of the static array
+   *
+   * \return The capacity of the static array
+   */
+  AXOM_HOST_DEVICE
+  constexpr axom::IndexType capacity() const
+  {
+    return static_cast<axom::IndexType>(N);
+  }
+
   /*!
    * \brief Returns the size of the static array
    *
    * \return The size of the static array
    */
-  AXOM_HOST_DEVICE int size() const { return m_size; }
+  AXOM_HOST_DEVICE
+  axom::IndexType size() const { return m_size; }
 
   /*!
    * \brief Pushes an object to the back of the static array
@@ -45,29 +59,51 @@ struct StaticArray : public StackArray<T, N>
    * \note If the static array is full, push_back
    *       will not modify the static array.
    */
-  AXOM_HOST_DEVICE void push_back(const T& obj)
+  AXOM_HOST_DEVICE
+  void push_back(const T &obj)
   {
-    assert(m_size < N);
-    if(m_size < N)
+    assert(m_size < capacity());
+    if(m_size < capacity())
     {
       StackArray<T, N>::m_data[m_size++] = obj;
     }
   }
 
+  /*!
+   * \brief Pops the last element off the list.
+   */
+  AXOM_HOST_DEVICE
+  void pop_back() { m_size = (m_size > 0) ? (m_size - 1) : 0; }
+
   /*!
    * \brief Clears the data from the static array
    */
-  AXOM_HOST_DEVICE void clear()
+  AXOM_HOST_DEVICE
+  void clear() { m_size = 0; }
+
+  /**
+   * \brief Determines whether the container is empty.
+   * \return True if empty, false otherwise.
+   */
+  AXOM_HOST_DEVICE
+  bool empty() const { return m_size == 0; }
+
+  /*!
+   * \brief Fills the container with the supplied value.
+   *
+   * \param fill_value The fill value.
+   */
+  AXOM_HOST_DEVICE
+  void fill(const T &fill_value)
   {
-    for(T& datum : StackArray<T, N>::m_data)
+    for(T &datum : StackArray<T, N>::m_data)
     {
-      datum = T();
+      datum = fill_value;
     }
-    m_size = 0;
   }
 
 private:
-  int m_size {0};
+  axom::IndexType m_size {0};
 };
 
 } /* namespace axom */

src/axom/core/execution/scans.hpp

@@ -0,0 +1,126 @@
+// Copyright (c) 2017-2024, Lawrence Livermore National Security, LLC and
+// other Axom Project Developers. See the top-level LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+
+#ifndef AXOM_CORE_EXECUTION_SCANS_HPP_
+#define AXOM_CORE_EXECUTION_SCANS_HPP_
+
+#include "axom/config.hpp"
+#include "axom/core/execution/execution_space.hpp"
+#include "axom/core/Macros.hpp"
+#include "axom/core/Types.hpp"
+
+// C/C++ includes
+#include <type_traits>
+#include <utility>
+
+namespace axom
+{
+/// \name Scans
+/// @{
+
+/*!
+ * \brief Performs exclusive scan over \a input view and stores result in \a output.
+ *
+ * \param [in] input The input container to be scanned.
+ * \param [out] output The container that will contain the output scan data. This 
+ *                     must have the same number of elements as \a input.
+ *
+ * \tparam ExecSpace the execution space where to run the supplied kernel
+ * \tparam ContiguousMemoryContainer The container type that holds the data
+ *
+ * \see axom::execution_space
+ *
+ * Usage Example:
+ * \code
+ *
+ *    axom::ArrayView<int> sizesView = sizes.view();
+ *    axom::ArrayView<int> offsetsView = offsets.view();
+ *
+ *    // Compute the scan for all elements in sizesView, store scan in offsetsView.
+ *    axom::exclusive_scan<ExecSpace>(sizesView, offsetsView);
+ *
+ * \endcode
+ *
+ */
+template <typename ExecSpace, typename ContiguousMemoryContainer>
+inline void exclusive_scan(const ContiguousMemoryContainer &input,
+                           ContiguousMemoryContainer &output)
+{
+  assert(input.size() == output.size());
+
+#ifdef AXOM_USE_RAJA
+
+  using loop_policy = typename axom::execution_space<ExecSpace>::loop_policy;
+  RAJA::exclusive_scan<loop_policy>(
+    RAJA::make_span(input.data(), input.size()),
+    RAJA::make_span(output.data(), output.size()));
+
+#else
+  constexpr bool is_serial = std::is_same<ExecSpace, SEQ_EXEC>::value;
+  AXOM_STATIC_ASSERT(is_serial);
+
+  typename ContiguousMemoryContainer::value_type total {0};
+  for(IndexType i = 0; i < input.size(); ++i)
+  {
+    output[i] = total;
+    total += input[i];
+  }
+#endif
+}
+
+/*!
+ * \brief Performs inclusive scan over \a input view and stores result in \a output.
+ *
+ * \param [in] input The input container to be scanned.
+ * \param [out] output The container that will contain the output scan data. This 
+ *                     must have the same number of elements as \a input.
+ *
+ * \tparam ExecSpace the execution space where to run the supplied kernel
+ * \tparam ContiguousMemoryContainer The container type that holds the data
+ *
+ * \see axom::execution_space
+ *
+ * Usage Example:
+ * \code
+ *
+ *    axom::ArrayView<int> sizesView = sizes.view();
+ *    axom::ArrayView<int> totalView = totals.view();
+ *
+ *    // Compute the scan for all elements in sizesView, store scan in totalView.
+ *    axom::inclusive_scan<ExecSpace>(sizesView, totalView);
+ *
+ * \endcode
+ *
+ */
+template <typename ExecSpace, typename ContiguousMemoryContainer>
+inline void inclusive_scan(const ContiguousMemoryContainer &input,
+                           ContiguousMemoryContainer &output)
+{
+  assert(input.size() == output.size());
+
+#ifdef AXOM_USE_RAJA
+
+  using loop_policy = typename axom::execution_space<ExecSpace>::loop_policy;
+  RAJA::inclusive_scan<loop_policy>(
+    RAJA::make_span(input.data(), input.size()),
+    RAJA::make_span(output.data(), output.size()));
+
+#else
+  constexpr bool is_serial = std::is_same<ExecSpace, SEQ_EXEC>::value;
+  AXOM_STATIC_ASSERT(is_serial);
+
+  typename ContiguousMemoryContainer::value_type total {0};
+  for(IndexType i = 0; i < input.size(); ++i)
+  {
+    total += input[i];
+    output[i] = total;
+  }
+#endif
+}
+/// @}
+
+}  // namespace axom
+
+#endif  // AXOM_CORE_EXECUTION_FOR_ALL_HPP_