Conduit Device Support

src/cmake/CMakeBasics.cmake

@@ -100,7 +100,7 @@ endif()
 # Device Support
 ################################
 set(CONDUIT_USE_CUDA FALSE)
-set(CONDUIT_USE_CUDA FALSE)
+set(CONDUIT_USE_HIP FALSE)
 
 if(ENABLE_CUDA)
     set(CONDUIT_USE_CUDA TRUE)
@@ -319,5 +319,3 @@ macro(convert_to_native_escaped_file_path path output)
     file(TO_NATIVE_PATH ${path} ${output})
     string(REPLACE "\\" "\\\\"  ${output} "${${output}}")
 endmacro()
-
-

src/config/CMakeLists.txt

@@ -86,5 +86,3 @@ install(FILES
         conduit_setup_deps.cmake
         conduit_setup_targets.cmake
         DESTINATION ${CONDUIT_INSTALL_CMAKE_MODULE_DIR}/conduit/)
-
-

src/config/ConduitConfig.cmake.in

@@ -30,8 +30,12 @@ set(CONDUIT_USE_CXX11   "@CONDUIT_USE_CXX11@")
 set(CONDUIT_USE_CXX14   "@CONDUIT_USE_CXX14@")
 set(CONDUIT_USE_FMT     "@CONDUIT_USE_FMT@")
 set(CONDUIT_USE_CALIPER "@CONDUIT_USE_CALIPER@")
+set(CONDUIT_USE_RAJA    "@RAJA_FOUND@")
+set(CONDUIT_USE_UMPIRE  "@UMPIRE_FOUND@")
 set(CONDUIT_USE_MPI     "@ENABLE_MPI@")
 set(CONDUIT_USE_OPENMP  "@ENABLE_OPENMP@")
+set(CONDUIT_USE_CUDA    "@ENABLE_CUDA@")
+set(CONDUIT_USE_HIP     "@ENABLE_HIP@")
 set(CONDUIT_INSTALL_PREFIX "@CONDUIT_INSTALL_PREFIX@")
 set(CONDUIT_ZLIB_DIR  "@ZLIB_DIR@")
 set(CONDUIT_HDF5_DIR  "@HDF5_DIR@")

src/config/conduit_setup_targets.cmake

@@ -76,6 +76,11 @@ set_property(TARGET conduit::conduit
              PROPERTY INTERFACE_LINK_LIBRARIES
              conduit conduit_relay conduit_blueprint)
 
+add_library(conduit::conduit_execution INTERFACE IMPORTED)
+set_property(TARGET conduit::conduit_execution
+             PROPERTY INTERFACE_LINK_LIBRARIES
+             conduit_execution)
+
 
 if(CONDUIT_PYTHON_ENABLED)
     # create convenience target that exposes the header file for the
@@ -118,8 +123,8 @@ if(NOT Conduit_FIND_QUIETLY)
     message(STATUS "CONDUIT_USE_FMT             = ${CONDUIT_USE_FMT}")
     message(STATUS "CONDUIT_USE_CALIPER         = ${CONDUIT_USE_CALIPER}")
     message(STATUS "CONDUIT_USE_OPENMP          = ${CONDUIT_USE_OPENMP}")
-    message(STATUS "CONDUIT_CUDA_ENABLED        = ${CONDUIT_CUDA_ENABLED}")
-    message(STATUS "CONDUIT_HIP_ENABLED         = ${CONDUIT_HIP_ENABLED}")
+    message(STATUS "CONDUIT_USE_CUDA            = ${CONDUIT_USE_CUDA}")
+    message(STATUS "CONDUIT_USE_HIP             = ${CONDUIT_USE_HIP}")
     message(STATUS "CONDUIT_INCLUDE_DIRS        = ${CONDUIT_INCLUDE_DIRS}")
     message(STATUS "CONDUIT_FORTRAN_ENABLED     = ${CONDUIT_FORTRAN_ENABLED}")
     message(STATUS "CONDUIT_PYTHON_ENABLED      = ${CONDUIT_PYTHON_ENABLED}")
@@ -137,7 +142,7 @@ if(NOT Conduit_FIND_QUIETLY)
     message(STATUS " CONDUIT_RELAY_MPI_ENABLED       = ${CONDUIT_RELAY_MPI_ENABLED}")
     message(STATUS " CONDUIT_USE_CMAKE_MPI_TARGETS   = ${CONDUIT_USE_CMAKE_MPI_TARGETS}")
 
-    set(_print_targets "conduit::conduit")
+    set(_print_targets "conduit::conduit conduit::conduit_execution")
 
     if(CONDUIT_PYTHON_ENABLED)
         set(_print_targets "${_print_targets} conduit::conduit_python")
@@ -151,4 +156,3 @@ if(NOT Conduit_FIND_QUIETLY)
     unset(_print_targets)
 endif()
 
-

src/libs/blueprint/CMakeLists.txt

@@ -247,5 +247,3 @@ blt_add_target_compile_flags(TO conduit_blueprint_mpi FLAGS "-DCONDUIT_BLUEPRINT
 target_compile_definitions(conduit_blueprint_mpi PUBLIC ${CONDUIT_MPI_SKIP_MPICXX_DEFINES} )
 
 endif() # end if MPI_FOUND
-
-

src/libs/blueprint/conduit_blueprint_mesh.cpp

@@ -8340,7 +8340,7 @@ void polyhedral_face_centers_normals(const IndexAccessor subelements_connectivit
     Vector *allFaceNormalsPtr = allFaceNormals.data();
 
     // Compute face centers and normals.
-    conduit::execution::for_all<ExecPolicy>(0, totalNumFaces, [=](conduit::index_t f) {
+    conduit::execution::forall<ExecPolicy>(0, totalNumFaces, [=](conduit::index_t f) {
         const int NUM_VERTS = 4;
         const auto size = subelements_sizes[f];
         const auto offset = subelements_offsets[f];
@@ -8457,7 +8457,7 @@ void polyhedral_elem_centers(const IndexAccessor elements_connectivity,
     allElemCenters.resize(totalNumElems);
     Vector *allElemCentersPtr = allElemCenters.data();
     const Vector *allFaceCentersPtr = allFaceCenters.data();
-    conduit::execution::for_all<ExecPolicy>(0, totalNumElems, [=](conduit::index_t i) {
+    conduit::execution::forall<ExecPolicy>(0, totalNumElems, [=](conduit::index_t i) {
         const auto size = elements_sizes[i];
         const auto offset = elements_offsets[i];
         Vector center {};
@@ -8580,7 +8580,7 @@ static void polyhedral_to_hexes(const conduit::Node &n_topo, conduit::Node &n_ou
     const Vector *allFaceCentersPtr = allFaceCenters.data();
     const Vector *allFaceNormalsPtr = allFaceNormals.data();
     const Vector *allElemCentersPtr = allElemCenters.data();
-    conduit::execution::for_all<ExecPolicy>(0, nElem, [=](conduit::index_t i) {
+    conduit::execution::forall<ExecPolicy>(0, nElem, [=](conduit::index_t i) {
         constexpr int FORWARD = 1;
         constexpr int BACKWARD = -1;
         // Determine face orientations with respect to this element.

src/libs/blueprint/conduit_blueprint_mesh_topology_metadata.cpp

@@ -60,14 +60,6 @@ namespace mesh
 namespace utils
 {
 
-// We may tag certain algorithms as ParallelExec if it is safe to do so.
-using SerialExec = conduit::execution::SerialExec;
-#if defined(CONDUIT_USE_OPENMP)
-using ParallelExec = conduit::execution::OpenMPExec;
-#else
-using ParallelExec = conduit::execution::SerialExec;
-#endif
-
 //---------------------------------------------------------------------------
 void
 yaml_print(std::ostream &os, const conduit::Node &node)
@@ -925,7 +917,8 @@ class TopologyMetadata::Implementation : public TopologyMetadataBase
         CONDUIT_ANNOTATE_MARK_BEGIN("Labeling");
         std::vector<std::pair<uint64, uint64>> faceid_to_ef(nelem_faces);
 
-        conduit::execution::for_all<ParallelExec>(0, nelem, [&](index_t elem)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, nelem, [&](index_t elem)
         {
             // Get the element faces, storing them all in face_pts.
             index_t elemstart = elem * points_per_elem;
@@ -963,7 +956,7 @@ class TopologyMetadata::Implementation : public TopologyMetadataBase
         // general faceid, then by their elemface "ef", which should keep the
         // elements in order.
         CONDUIT_ANNOTATE_MARK_BEGIN("Sort labels");
-        conduit::execution::sort<ParallelExec>(faceid_to_ef.begin(), faceid_to_ef.end());
+        conduit::execution::sort(policy, faceid_to_ef.begin(), faceid_to_ef.end());
         CONDUIT_ANNOTATE_MARK_END("Sort labels");
 #ifdef DEBUG_PRINT
         std::cout << "faceid_to_ef.sorted = " << faceid_to_ef << std::endl;
@@ -982,8 +975,8 @@ class TopologyMetadata::Implementation : public TopologyMetadataBase
 #endif
 
         // Sort on ef to get back to a ef->unique mapping.
-        conduit::execution::sort<ParallelExec>(
-            ef_to_unique.begin(), ef_to_unique.end(),
+        conduit::execution::sort(
+            policy, ef_to_unique.begin(), ef_to_unique.end(),
             [&](const std::pair<uint64, uint64> &lhs, const std::pair<uint64, uint64> &rhs)
             {
                 // Only sort using the ef value.
@@ -1135,7 +1128,8 @@ class TopologyMetadata::Implementation : public TopologyMetadataBase
         std::vector<std::pair<uint64, uint64>> edgeid_to_ee(nelem_edges);
         std::vector<std::pair<index_t, index_t>> ee_to_edge(nelem_edges);
 
-        conduit::execution::for_all<ParallelExec>(0, nelem, [&](index_t elem)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, nelem, [&](index_t elem)
         {
             constexpr size_t MAX_VERTS = 32;
 
@@ -1173,7 +1167,7 @@ class TopologyMetadata::Implementation : public TopologyMetadataBase
 
         // Sort edgeid_to_ee so any like edges will be sorted.
         CONDUIT_ANNOTATE_MARK_BEGIN("Sort labels");
-        conduit::execution::sort<ParallelExec>(edgeid_to_ee.begin(), edgeid_to_ee.end());
+        conduit::execution::sort(policy, edgeid_to_ee.begin(), edgeid_to_ee.end());
         CONDUIT_ANNOTATE_MARK_END("Sort labels");
 #ifdef DEBUG_PRINT
         std::cout << "edgeid_to_ee.sorted = " << edgeid_to_ee << std::endl;
@@ -1189,8 +1183,8 @@ class TopologyMetadata::Implementation : public TopologyMetadataBase
 #endif
 
         // Sort on ef to get back to a ef->unique mapping.
-        conduit::execution::sort<ParallelExec>(
-            ee_to_unique.begin(), ee_to_unique.end(),
+        conduit::execution::sort(
+            policy, ee_to_unique.begin(), ee_to_unique.end(),
             [&](const std::pair<uint64, uint64> &lhs, const std::pair<uint64, uint64> &rhs)
             {
                 // Only sort using the ee value.
@@ -2167,11 +2161,11 @@ TopologyMetadata::Implementation::build_edge_key_to_id(
 #ifdef DEBUG_PRINT
     std::cout << "edges_key_to_id = {" << std::endl;
     // Because of the printing.
-    using Exec = SerialExec;
+    conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::serial();
 #else
-    using Exec = ParallelExec;
+    conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
 #endif
-    conduit::execution::for_all<Exec>(0, nedges, [&](index_t edge_index)
+    conduit::execution::forall(policy, 0, nedges, [&](index_t edge_index)
     {
         // Make a key for this edge.
         index_t edge[2];
@@ -2193,8 +2187,9 @@ TopologyMetadata::Implementation::build_edge_key_to_id(
 #endif
 
     // Sort the edges by the ids.
-    conduit::execution::sort<ParallelExec>(
-        edge_key_to_id.begin(), edge_key_to_id.end(),
+    conduit::execution::ExecutionPolicy sort_policy = conduit::execution::ExecutionPolicy::host();
+    conduit::execution::sort(
+        sort_policy, edge_key_to_id.begin(), edge_key_to_id.end(),
         [&](const std::pair<uint64, index_t> &lhs,
             const std::pair<uint64, index_t> &rhs) 
         {
@@ -2288,7 +2283,8 @@ TopologyMetadata::Implementation::build_association_3_1_and_3_0_nonph()
     // Iterate over the elements, applying the edge template to make unique
     // edges for the element. We look up the edge in edge_key_to_id to get
     // its id.
-    conduit::execution::for_all<ParallelExec>(0, nelem, [&](index_t ei)
+    conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+    conduit::execution::forall(policy, 0, nelem, [&](index_t ei)
     {
         index_t elem_offset = ei * points_per_elem;
 
@@ -2487,7 +2483,8 @@ TopologyMetadata::Implementation::build_child_to_parent_association(int e, int a
     std::cout << "p2c=" << p2c << std::endl;
 #endif
     // Sort p2c by child.
-    conduit::execution::sort<ParallelExec>(p2c.begin(), p2c.end(),
+    conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+    conduit::execution::sort(policy, p2c.begin(), p2c.end(),
         [&](const std::pair<index_t, index_t> &lhs,
             const std::pair<index_t, index_t> &rhs)
     {

src/libs/blueprint/conduit_blueprint_mesh_utils.cpp

@@ -4576,12 +4576,6 @@ PointQuery::acceleratedSearch(int ndims,
     int *result_ptr = &result[0];
     conduit::index_t numCoordsetPts = coords[0]->dtype().number_of_elements();
 
-#if defined(CONDUIT_USE_OPENMP)
-    using policy = conduit::execution::OpenMPExec;
-#else
-    using policy = conduit::execution::SerialExec;
-#endif
-
     // Special case a few large searches where the types are the same.
     if(ndims == 3 &&
        sameTypes &&
@@ -4596,7 +4590,8 @@ PointQuery::acceleratedSearch(int ndims,
         conduit::blueprint::mesh::utils::kdtree<float64_array, float64, 3> search;
         search.initialize(typedCoords, numCoordsetPts);
         search.setPointTolerance(m_pointTolerance);
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             float64 searchPt[3] = {static_cast<float64>(input_ptr[i * 3 + 0]),
                                    static_cast<float64>(input_ptr[i * 3 + 1]),
@@ -4619,7 +4614,8 @@ PointQuery::acceleratedSearch(int ndims,
         conduit::blueprint::mesh::utils::kdtree<float32_array, float32, 3> search;
         search.initialize(typedCoords, numCoordsetPts);
         search.setPointTolerance(static_cast<float32>(m_pointTolerance));
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             float32 searchPt[3] = {static_cast<float32>(input_ptr[i * 3 + 0]),
                                    static_cast<float32>(input_ptr[i * 3 + 1]),
@@ -4642,7 +4638,8 @@ PointQuery::acceleratedSearch(int ndims,
         conduit::blueprint::mesh::utils::kdtree<float64_array, float64, 2> search;
         search.initialize(typedCoords, numCoordsetPts);
         search.setPointTolerance(m_pointTolerance);
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             float64 searchPt[2] = {static_cast<float64>(input_ptr[i * 3 + 0]),
                                    static_cast<float64>(input_ptr[i * 3 + 1])};
@@ -4663,7 +4660,8 @@ PointQuery::acceleratedSearch(int ndims,
         conduit::blueprint::mesh::utils::kdtree<float32_array, float32, 2> search;
         search.initialize(typedCoords, numCoordsetPts);
         search.setPointTolerance(static_cast<float32>(m_pointTolerance));
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             float32 searchPt[2] = {static_cast<float32>(input_ptr[i * 3 + 0]),
                                    static_cast<float32>(input_ptr[i * 3 + 1])};
@@ -4693,16 +4691,11 @@ PointQuery::normalSearch(int ndims,
     conduit::index_t numCoordsetPts = coords[0]->dtype().number_of_elements();
     double EPS_SQ = m_pointTolerance * m_pointTolerance;
 
-#if defined(CONDUIT_USE_OPENMP)
-    using policy = conduit::execution::OpenMPExec;
-#else
-    using policy = conduit::execution::SerialExec;
-#endif
-
     // Back up to a brute force search
     if(ndims == 3)
     {
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             const double *searchPt = &input_ptr[i * 3];
             int found = NotFound;
@@ -4727,7 +4720,8 @@ PointQuery::normalSearch(int ndims,
     }
     else if(ndims == 2)
     {
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             const double *searchPt = &input_ptr[i * 3];
             int found = NotFound;
@@ -4750,7 +4744,8 @@ PointQuery::normalSearch(int ndims,
     }
     else if(ndims == 1)
     {
-        conduit::execution::for_all<policy>(0, numInputPts, [&](conduit::index_t i)
+        conduit::execution::ExecutionPolicy policy = conduit::execution::ExecutionPolicy::host();
+        conduit::execution::forall(policy, 0, numInputPts, [&](conduit::index_t i)
         {
             const double *searchPt = &input_ptr[i * 3];
             int found = NotFound;

src/libs/conduit/CMakeLists.txt

@@ -50,8 +50,12 @@ set(conduit_headers
     conduit_data_type.hpp
     conduit_endianness.hpp
     conduit_execution.hpp
-    conduit_execution_omp.hpp
-    conduit_execution_serial.hpp
+    conduit_execution_policy.hpp
+    conduit_execution_core.hpp
+    conduit_memory_manager.hpp
+    conduit_data_array.hpp
+    conduit_data_accessor.hpp
+    conduit_data_type.hpp
     conduit_fixed_size_map.hpp
     conduit_fixed_size_vector.hpp
     conduit_geometry_vector.hpp
@@ -89,6 +93,8 @@ set(conduit_sources
     conduit_core.cpp
     conduit_error.cpp
     conduit_endianness.cpp
+    conduit_execution.cpp
+    conduit_memory_manager.cpp
     conduit_data_type.cpp
     conduit_data_array.cpp
     conduit_data_accessor.cpp
@@ -158,6 +164,18 @@ if(CALIPER_FOUND)
     list(APPEND conduit_thirdparty_libs caliper)
 endif()
 
+if(RAJA_FOUND)
+    list(APPEND conduit_thirdparty_libs RAJA)
+endif()
+
+if(UMPIRE_FOUND)
+    list(APPEND conduit_thirdparty_libs umpire)
+endif()
+
+if(HIP_FOUND)
+    list(APPEND conduit_thirdparty_libs blt::hip_runtime)
+endif()
+
 if(OPENMP_FOUND)
     list(APPEND conduit_thirdparty_libs ${conduit_blt_openmp_deps})
 endif()
@@ -185,6 +203,11 @@ target_include_directories(conduit
                            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
                            $<$<BOOL:TOTALVIEW_FOUND>:${TOTALVIEW_INCLUDE_DIRECTORIES}>)
 
+add_library(conduit_execution INTERFACE)
+add_library(conduit::conduit_execution ALIAS conduit_execution)
+target_link_libraries(conduit_execution INTERFACE conduit)
+install(TARGETS conduit_execution EXPORT conduit)
+
 
 #################################
 # Fortran related target options
@@ -218,4 +241,3 @@ if(FORTRAN_FOUND)
    ${CMAKE_Fortran_MODULE_DIRECTORY}/
    DESTINATION include/conduit)
 endif()
-

src/libs/conduit/conduit.hpp

@@ -26,6 +26,6 @@
 #include "conduit_generator.hpp"
 #include "conduit_utils.hpp"
 #include "conduit_data_accessor.hpp"
+#include "conduit_memory_manager.hpp"
 
 #endif
-