Feature: Add profiling label support to splines and parallel reduce (#1114)

* Added profiling labels on the allocations in spline builders and evaluators

* Added profiling labels support to parallel transforms

* Apply suggestion from @tpadioleau

* Format

* Use concepts instead of sfinae

* Pass by copy for constructors

* Add Kevin to AUTHORS

* Format

---------

Co-authored-by: Thomas Padioleau <thomas.padioleau@cea.fr>

Author: obrejank

AUTHORS

@@ -64,3 +64,4 @@ Padioleau Thomas - CEA (<thomas.padioleau@cea.fr>)
 ## Minor contributions
 
 Md. Sajid Khan
+Kevin Obrejan

src/ddc/kernels/fft.hpp

@@ -223,7 +223,7 @@ void impl(
             norm_coef = (backward_full_norm_coef(DiscreteDomain<DDimOut>(ddom_out)) * ...);
         }
 
-        ddc::parallel_transform(exec_space, out, ScaleFn<real_type_t<Tout>>(norm_coef));
+        ddc::parallel_transform("ddc_fft", exec_space, out, ScaleFn<real_type_t<Tout>>(norm_coef));
     }
 }
 

src/ddc/kernels/splines/spline_builder.hpp

@@ -200,13 +200,17 @@ class SplineBuilder
     // interpolator specific
     std::unique_ptr<ddc::detail::SplinesLinearProblem<exec_space>> m_matrix;
 
+    std::string m_label;
+
     /// Calculate offset so that the matrix is diagonally dominant
     void compute_offset(interpolation_domain_type const& interpolation_domain, int& offset);
 
 public:
     /**
      * @brief Build a SplineBuilder acting on interpolation_domain.
      *
+     * @param label A label used to tag parallel regions and memory allocations for profiling.
+     *
      * @param interpolation_domain The domain on which the interpolation points are defined.
      *
      * @param cols_per_chunk A parameter used by the slicer (internal to the solver) to define the size
@@ -221,12 +225,14 @@ class SplineBuilder
      * @see MatrixSparse
      */
     explicit SplineBuilder(
+            std::string label,
             interpolation_domain_type const& interpolation_domain,
             std::optional<std::size_t> cols_per_chunk = std::nullopt,
             std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
         : m_interpolation_domain(interpolation_domain)
         , m_dx((ddc::discrete_space<BSplines>().rmax() - ddc::discrete_space<BSplines>().rmin())
                / ddc::discrete_space<BSplines>().ncells())
+        , m_label(std::move(label))
     {
         static_assert(
                 ((BcLower == BoundCond::PERIODIC) == (BcUpper == BoundCond::PERIODIC)),
@@ -252,6 +258,66 @@ class SplineBuilder
                 preconditioner_max_block_size);
     }
 
+    /**
+     * @brief Build a SplineBuilder acting on interpolation_domain.
+     *
+     * @param interpolation_domain The domain on which the interpolation points are defined.
+     *
+     * @param cols_per_chunk A parameter used by the slicer (internal to the solver) to define the size
+     * of a chunk of right-hand sides of the linear problem to be computed in parallel (chunks are treated
+     * by the linear solver one-after-the-other).
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @param preconditioner_max_block_size A parameter used by the slicer (internal to the solver) to
+     * define the size of a block used by the Block-Jacobi preconditioner.
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @see MatrixSparse
+     */
+    explicit SplineBuilder(
+            interpolation_domain_type const& interpolation_domain,
+            std::optional<std::size_t> cols_per_chunk = std::nullopt,
+            std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
+        : SplineBuilder(
+                  "no-label",
+                  interpolation_domain,
+                  cols_per_chunk,
+                  preconditioner_max_block_size)
+    {
+    }
+
+    /**
+     * @brief Build a SplineBuilder acting on the interpolation domain contained by batched_interpolation_domain.
+     *
+     * @param label A label used to tag parallel regions and memory allocations for profiling.
+     *
+     * @param batched_interpolation_domain The whole domain on which the interpolation points are defined.
+     *
+     * @param cols_per_chunk A parameter used by the slicer (internal to the solver) to define the size
+     * of a chunk of right-hand sides of the linear problem to be computed in parallel (chunks are treated
+     * by the linear solver one-after-the-other).
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @param preconditioner_max_block_size A parameter used by the slicer (internal to the solver) to
+     * define the size of a block used by the Block-Jacobi preconditioner.
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @see MatrixSparse
+     */
+    template <concepts::discrete_domain BatchedInterpolationDDom>
+    explicit SplineBuilder(
+            std::string label,
+            BatchedInterpolationDDom const& batched_interpolation_domain,
+            std::optional<std::size_t> cols_per_chunk = std::nullopt,
+            std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
+        : SplineBuilder(
+                  std::move(label),
+                  interpolation_domain_type(batched_interpolation_domain),
+                  cols_per_chunk,
+                  preconditioner_max_block_size)
+    {
+    }
+
     /**
      * @brief Build a SplineBuilder acting on the interpolation domain contained by batched_interpolation_domain.
      *
@@ -274,6 +340,7 @@ class SplineBuilder
             std::optional<std::size_t> cols_per_chunk = std::nullopt,
             std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
         : SplineBuilder(
+                  "no-label",
                   interpolation_domain_type(batched_interpolation_domain),
                   cols_per_chunk,
                   preconditioner_max_block_size)
@@ -938,11 +1005,12 @@ operator()(
     // Allocate and fill a transposed version of spline in order to get dimension of interest as last dimension (optimal for GPU, necessary for Ginkgo). Also select only relevant rows in case of periodic boundaries
     auto const& offset_proxy = m_offset;
     ddc::Chunk spline_tr_alloc(
+            m_label + " > spline_tr (ddc::SplineBuilder::operator())",
             batched_spline_tr_domain(batched_interpolation_domain),
             ddc::KokkosAllocator<double, memory_space>());
     ddc::ChunkSpan const spline_tr = spline_tr_alloc.span_view();
     ddc::parallel_for_each(
-            "ddc_splines_transpose_rhs",
+            m_label + " > ddc_splines_transpose_rhs",
             exec_space(),
             batch_domain(batched_interpolation_domain),
             KOKKOS_LAMBDA(
@@ -961,7 +1029,7 @@ operator()(
     m_matrix->solve(bcoef_section, false);
     // Transpose back spline_tr into spline.
     ddc::parallel_for_each(
-            "ddc_splines_transpose_back_rhs",
+            m_label + " > ddc_splines_transpose_back_rhs",
             exec_space(),
             batch_domain(batched_interpolation_domain),
             KOKKOS_LAMBDA(
@@ -975,7 +1043,7 @@ operator()(
     // Duplicate the lower spline coefficients to the upper side in case of periodic boundaries
     if (bsplines_type::is_periodic()) {
         ddc::parallel_for_each(
-                "ddc_splines_periodic_rows_duplicate_rhs",
+                m_label + " > ddc_splines_periodic_rows_duplicate_rhs",
                 exec_space(),
                 batch_domain(batched_interpolation_domain),
                 KOKKOS_LAMBDA(
@@ -1041,7 +1109,7 @@ SplineBuilder<ExecSpace, MemorySpace, BSplines, InterpolationDDim, BcLower, BcUp
     // Allocate mirror with additional rows (cf. SplinesLinearProblem3x3Blocks documentation)
     Kokkos::View<double**, Kokkos::LayoutRight, MemorySpace> const
             integral_bsplines_mirror_with_additional_allocation(
-                    "integral_bsplines_mirror_with_additional_allocation",
+                    m_label + " > integral_bsplines_mirror_with_additional_allocation",
                     m_matrix->required_number_of_rhs_rows(),
                     1);
 

src/ddc/kernels/splines/spline_builder_2d.hpp

@@ -7,6 +7,7 @@
 #include <cassert>
 #include <cstddef>
 #include <optional>
+#include <string>
 
 #include <ddc/ddc.hpp>
 
@@ -179,8 +180,46 @@ class SplineBuilder2D
 private:
     builder_type1 m_spline_builder1;
     builder_type2 m_spline_builder2;
+    std::string m_label;
 
 public:
+    /**
+     * @brief Build a SplineBuilder2D acting on interpolation_domain.
+     *
+     * @param label A label used to tag parallel regions and memory allocations for profiling.
+     *
+     * @param interpolation_domain The domain on which the interpolation points are defined, without the batch dimensions.
+     *
+     * @param cols_per_chunk A parameter used by the slicer (internal to the solver) to define the size
+     * of a chunk of right-hand-sides of the linear problem to be computed in parallel (chunks are treated
+     * by the linear solver one-after-the-other).
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @param preconditioner_max_block_size A parameter used by the slicer (internal to the solver) to
+     * define the size of a block used by the Block-Jacobi preconditioner.
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @see SplinesLinearProblemSparse
+     */
+    explicit SplineBuilder2D(
+            std::string const& label,
+            interpolation_domain_type const& interpolation_domain,
+            std::optional<std::size_t> cols_per_chunk = std::nullopt,
+            std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
+        : m_spline_builder1(
+                  label,
+                  interpolation_domain,
+                  cols_per_chunk,
+                  preconditioner_max_block_size)
+        , m_spline_builder2(
+                  label,
+                  interpolation_domain,
+                  cols_per_chunk,
+                  preconditioner_max_block_size)
+        , m_label(label)
+    {
+    }
+
     /**
      * @brief Build a SplineBuilder2D acting on interpolation_domain.
      *
@@ -201,8 +240,43 @@ class SplineBuilder2D
             interpolation_domain_type const& interpolation_domain,
             std::optional<std::size_t> cols_per_chunk = std::nullopt,
             std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
-        : m_spline_builder1(interpolation_domain, cols_per_chunk, preconditioner_max_block_size)
-        , m_spline_builder2(interpolation_domain, cols_per_chunk, preconditioner_max_block_size)
+        : SplineBuilder2D(
+                  "no-label",
+                  interpolation_domain,
+                  cols_per_chunk,
+                  preconditioner_max_block_size)
+    {
+    }
+
+    /**
+     * @brief Build a SplineBuilder2D acting on the interpolation domain contained in batched_interpolation_domain.
+     *
+     * @param label A label used to tag parallel regions and memory allocations for profiling.
+     *
+     * @param batched_interpolation_domain The domain on which the interpolation points are defined.
+     *
+     * @param cols_per_chunk A parameter used by the slicer (internal to the solver) to define the size
+     * of a chunk of right-hand-sides of the linear problem to be computed in parallel (chunks are treated
+     * by the linear solver one-after-the-other).
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @param preconditioner_max_block_size A parameter used by the slicer (internal to the solver) to
+     * define the size of a block used by the Block-Jacobi preconditioner.
+     * This value is optional. If no value is provided then the default value is chosen by the requested solver.
+     *
+     * @see SplinesLinearProblemSparse
+     */
+    template <concepts::discrete_domain BatchedInterpolationDDom>
+    explicit SplineBuilder2D(
+            std::string const& label,
+            BatchedInterpolationDDom const& batched_interpolation_domain,
+            std::optional<std::size_t> cols_per_chunk = std::nullopt,
+            std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
+        : SplineBuilder2D(
+                  label,
+                  interpolation_domain_type(batched_interpolation_domain),
+                  cols_per_chunk,
+                  preconditioner_max_block_size)
     {
     }
 
@@ -228,6 +302,7 @@ class SplineBuilder2D
             std::optional<std::size_t> cols_per_chunk = std::nullopt,
             std::optional<unsigned int> preconditioner_max_block_size = std::nullopt)
         : SplineBuilder2D(
+                  "no-label",
                   interpolation_domain_type(batched_interpolation_domain),
                   cols_per_chunk,
                   preconditioner_max_block_size)
@@ -530,6 +605,7 @@ operator()(
                             ddc::DiscreteVector<deriv_type2>(bsplines_type2::degree() / 2)));
 
     ddc::Chunk spline1_deriv_min_alloc(
+            m_label + " > spline1_deriv_min (ddc::SplineBuilder2D::operator())",
             m_spline_builder1.batched_spline_domain(batched_interpolation_deriv_domain),
             ddc::KokkosAllocator<double, MemorySpace>());
     auto spline1_deriv_min = spline1_deriv_min_alloc.span_view();
@@ -546,6 +622,7 @@ operator()(
 
     // Spline1-approximate vals (to spline1)
     ddc::Chunk spline1_alloc(
+            m_label + " > spline1 (ddc::SplineBuilder2D::operator())",
             m_spline_builder1.batched_spline_domain(batched_interpolation_domain),
             ddc::KokkosAllocator<double, MemorySpace>());
     ddc::ChunkSpan const spline1 = spline1_alloc.span_view();
@@ -554,6 +631,7 @@ operator()(
 
     // Spline1-approximate derivs_max2 (to spline1_deriv_max)
     ddc::Chunk spline1_deriv_max_alloc(
+            m_label + " > spline1_deriv_max (ddc::SplineBuilder2D::operator())",
             m_spline_builder1.batched_spline_domain(batched_interpolation_deriv_domain),
             ddc::KokkosAllocator<double, MemorySpace>());
     auto spline1_deriv_max = spline1_deriv_max_alloc.span_view();