Conduit Device Support

src/libs/blueprint/conduit_blueprint_mesh.cpp

@@ -8324,7 +8324,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];
@@ -8441,7 +8441,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 {};
@@ -8564,7 +8564,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

@@ -4528,12 +4528,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 &&
@@ -4548,7 +4542,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]),
@@ -4571,7 +4566,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]),
@@ -4594,7 +4590,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])};
@@ -4615,7 +4612,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])};
@@ -4645,16 +4643,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;
@@ -4679,7 +4672,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;
@@ -4702,7 +4696,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,10 @@ set(conduit_headers
     conduit_data_type.hpp
     conduit_endianness.hpp
     conduit_execution.hpp
-    conduit_execution_omp.hpp
-    conduit_execution_serial.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 +91,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

src/libs/conduit/conduit.hpp

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