add caliper support for bdddc

Author: pratikvn

CMakeLists.txt

@@ -369,6 +369,12 @@ find_package(VTune)
 if(VTune_FOUND)
     set(GINKGO_HAVE_VTUNE 1)
 endif()
+# Automatically find Caliper
+set(GINKGO_HAVE_CALIPER 0)
+find_package(caliper QUIET)
+if(caliper_FOUND)
+    set(GINKGO_HAVE_CALIPER 1)
+endif()
 # Automatically find METIS
 set(GINKGO_HAVE_METIS 0)
 find_package(METIS)

core/CMakeLists.txt

@@ -214,6 +214,10 @@ if(GINKGO_HAVE_PARMETIS)
     target_link_libraries(${ginkgo_core} PRIVATE ParMETIS::ParMETIS)
 endif()
 
+if(GINKGO_HAVE_CALIPER)
+    target_link_libraries(${ginkgo_core} PRIVATE caliper)
+endif()
+
 if(GINKGO_BUILD_MPI)
     target_link_libraries(${ginkgo_core} PUBLIC MPI::MPI_CXX)
 endif()

core/base/caliper.hpp

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_CORE_BASE_CALIPER_HPP_
+#define GKO_CORE_BASE_CALIPER_HPP_
+
+#include <ginkgo/config.hpp>
+
+#if GKO_HAVE_CALIPER
+#include <caliper/cali.h>
+#else
+#define CALI_CXX_MARK_SCOPE(name)
+#define CALI_MARK_BEGIN(name)
+#define CALI_MARK_END(name)
+#endif
+
+#endif  // GKO_CORE_BASE_CALIPER_HPP_

core/distributed/preconditioner/bddc.cpp

@@ -40,6 +40,7 @@
 #include <ginkgo/core/stop/iteration.hpp>
 #include <ginkgo/core/stop/residual_norm.hpp>
 
+#include "core/base/caliper.hpp"
 #include "core/base/extended_float.hpp"
 #include "core/base/utils.hpp"
 #include "core/components/fill_array_kernels.hpp"
@@ -361,14 +362,18 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::apply_dense_impl(
     using Vector = matrix::Dense<ValueType>;
     auto exec = this->get_executor();
     auto comm = buf_1_->get_communicator();
+    CALI_CXX_MARK_SCOPE("bddc::apply");
 
+    CALI_MARK_BEGIN("bddc::apply/restriction");
     restriction_->apply(dense_b, buf_2_);
     if (active) {
         local_buf_2_->permute(permutation_, local_buf_1_,
                               matrix::permute_mode::rows);
         local_buf_4_->copy_from(local_buf_1_);
     }
+    CALI_MARK_END("bddc::apply/restriction");
 
+    CALI_MARK_BEGIN("bddc::apply/static_condensation_1");
     if (!pre_solved) {
         if (active) {
             // Static condensation 1
@@ -386,15 +391,19 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::apply_dense_impl(
         }
         bndry_1_->add_scaled(neg_one_, bndry_3_);
     }
+    CALI_MARK_END("bddc::apply/static_condensation_1");
 
+    CALI_MARK_BEGIN("bddc::apply/weight_application");
     if (active) {
         interior_1_->fill(zero<ValueType>());
         weights_->apply(local_buf_1_, local_buf_2_);
 
         // Coarse grid correction
         phi_t_->apply(bndry_2_, local_coarse_buf_1_);
     }
+    CALI_MARK_END("bddc::apply/weight_application");
 
+    CALI_MARK_BEGIN("bddc::apply/coarse_correction");
     coarse_prolongation_->apply(broken_coarse_buf_1_, coarse_buf_1_);
     if (coarse_solver_->apply_uses_initial_guess()) {
         coarse_buf_2_->fill(zero<ValueType>());
@@ -403,7 +412,11 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::apply_dense_impl(
     coarse_restriction_->apply(coarse_buf_2_, broken_coarse_buf_1_);
     if (active) {
         phi_->apply(local_coarse_buf_1_, bndry_1_);
+    }
+    CALI_MARK_END("bddc::apply/coarse_correction");
 
+    CALI_MARK_BEGIN("bddc::apply/substructure_correction");
+    if (active) {
         // Substructure correction
         local_solver_->apply(dual_2_, dual_3_);
         constraints_->apply(dual_3_, schur_buf_1_);
@@ -419,6 +432,9 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::apply_dense_impl(
         local_buf_2_->permute(permutation_, local_buf_1_,
                               matrix::permute_mode::inverse_rows);
     }
+    CALI_MARK_END("bddc::apply/substructure_correction");
+
+    CALI_MARK_BEGIN("bddc::apply/static_condensation_2");
     prolongation_->apply(buf_1_, dense_x);
     restriction_->apply(dense_x, buf_1_);
     if (active) {
@@ -434,13 +450,17 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::apply_dense_impl(
         local_buf_2_->permute(permutation_, local_buf_1_,
                               matrix::permute_mode::inverse_rows);
     }
+    CALI_MARK_END("bddc::apply/static_condensation_2");
+
+    CALI_MARK_BEGIN("bddc::apply/prolongation");
     prolongation_->apply(one_, buf_1_, one_, dense_x);
 
     if (parameters_.constant_nullspace) {
         dense_x->compute_dot(nsp, LL_scal_3);
         LL_scal_3->inv_scale(n_op);
         dense_x->add_scaled(LL_scal_3, nsp);
     }
+    CALI_MARK_END("bddc::apply/prolongation");
 }
 
 
@@ -1524,6 +1544,7 @@ template <typename ValueType, typename LocalIndexType, typename GlobalIndexType>
 void Bddc<ValueType, LocalIndexType, GlobalIndexType>::generate(
     std::shared_ptr<const LinOp> system_matrix)
 {
+    CALI_CXX_MARK_SCOPE("bddc::generate");
     auto exec = this->get_executor();
     auto host_exec = exec->get_master();
 
@@ -1584,12 +1605,14 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::generate(
     size_type n_inner_idxs, n_face_idxs, n_edge_idxs, n_vertices, n_faces,
         n_edges, n_constraints;
     int n_owning_interfaces;
+    CALI_MARK_BEGIN("bddc::generate/classify_dofs");
     auto labels = bddc::classify_dofs(
         host_exec, dd_system_matrix, tags, dof_types, permutation_array,
         interface_sizes, unique_labels, unique_tags, owning_labels, owning_tags,
         n_inner_idxs, n_face_idxs, n_edge_idxs, n_vertices, n_faces, n_edges,
         n_constraints, n_owning_interfaces, parameters_.faces,
         parameters_.edges);
+    CALI_MARK_END("bddc::generate/classify_dofs");
 
     if (exec != host_exec) {
         labels = clone(exec, labels);
@@ -1645,9 +1668,13 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::generate(
             share(as<local_real_vec>(labels->get_local_vector())
                       ->permute(permutation_, matrix::permute_mode::rows));
 
+        CALI_MARK_BEGIN("bddc::generate/extract_matrix_blocks");
         extract_matrix_blocks(reordered_system_matrix, n_inner_idxs,
                               n_face_idxs, n_edge_idxs, n_vertices);
+        CALI_MARK_END("bddc::generate/extract_matrix_blocks");
+        CALI_MARK_BEGIN("bddc::generate/setup_local_solvers");
         setup_local_solvers(n_inner_idxs, n_face_idxs, n_edge_idxs, n_vertices);
+        CALI_MARK_END("bddc::generate/setup_local_solvers");
 
         matrix_data<ValueType, LocalIndexType> condest_LL_data(
             gko::dim<2>{A_LL->get_size()[0], 1},
@@ -1660,16 +1687,22 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::generate(
         auto condest_rhs_II = local_vec::create(exec);
         condest_rhs_II->read(condest_II_data);
 
+        CALI_MARK_BEGIN("bddc::generate/setup_nullspace_and_conditioning");
         setup_nullspace_and_conditioning(share(std::move(condest_rhs_LL)),
                                          share(std::move(condest_rhs_II)));
+        CALI_MARK_END("bddc::generate/setup_nullspace_and_conditioning");
 
+        CALI_MARK_BEGIN("bddc::generate/generate_constraints_and_schur");
         generate_constraints_and_schur(local_labels, n_inactive, n_dual,
                                        interface_sizes, n_inner_idxs,
                                        n_face_idxs, n_edge_idxs);
+        CALI_MARK_END("bddc::generate/generate_constraints_and_schur");
 
+        CALI_MARK_BEGIN("bddc::generate/compute_harmonic_extensions");
         compute_harmonic_extensions(phi, lambda, n_inner_idxs, n_face_idxs,
                                     n_edge_idxs, n_vertices, n_dual,
                                     n_constraints);
+        CALI_MARK_END("bddc::generate/compute_harmonic_extensions");
     }
 
     // Set up global numbering for coarse problem, read coarse matrix and
@@ -1680,26 +1713,35 @@ void Bddc<ValueType, LocalIndexType, GlobalIndexType>::generate(
     array<LocalIndexType> coarse_global_idxs{host_exec};
 
     array<int> owning_interfaces{host_exec, num_parts + 1};
+    CALI_MARK_BEGIN("bddc::generate/assemble_coarse_problem");
     assemble_coarse_problem(
         labels, lambda, dof_types, unique_tags, unique_labels, owning_labels,
         owning_tags, n_constraints, n_owning_interfaces, owning_interfaces,
         coarse_contribution, coarse_global_idxs);
+    CALI_MARK_END("bddc::generate/assemble_coarse_problem");
     size_type n_global_interfaces = coarse_partition_->get_size();
 
+    CALI_MARK_BEGIN("bddc::generate/setup_coarse_solver");
     setup_coarse_solver(coarse_contribution, coarse_partition_, n_constraints,
                         local_size, owning_interfaces, coarse_global_idxs);
+    CALI_MARK_END("bddc::generate/setup_coarse_solver");
 
+    CALI_MARK_BEGIN("bddc::generate/setup_coarse_mapping");
     setup_coarse_mapping(coarse_contribution, coarse_partition_, phi,
                          coarse_global_idxs, n_inner_idxs, n_face_idxs,
                          n_edge_idxs, n_vertices, n_constraints);
+    CALI_MARK_END("bddc::generate/setup_coarse_mapping");
 
-    // Create workspace buffers
+    CALI_MARK_BEGIN("bddc::generate/create_workspace_buffers");
     create_workspace_buffers(local_size, n_inner_idxs, n_face_idxs, n_edge_idxs,
                              n_vertices, n_dual, n_constraints,
                              n_owning_interfaces, n_global_interfaces);
+    CALI_MARK_END("bddc::generate/create_workspace_buffers");
 
+    CALI_MARK_BEGIN("bddc::generate/generate_weights");
     generate_weights(local_size, n_inner_idxs, n_face_idxs, n_inactive,
                      interface_sizes, permutation_array, unique_labels);
+    CALI_MARK_END("bddc::generate/generate_weights");
 
     nsp = vec::create(
         exec, comm, dim<2>{prolongation_->get_size()[0], 1},

include/ginkgo/config.hpp.in

@@ -114,6 +114,11 @@
 #define GKO_HAVE_ROCTX @GINKGO_HAVE_ROCTX@
 // clang-format on
 
+/* Is Caliper available for Profiling? */
+// clang-format off
+#define GKO_HAVE_CALIPER @GINKGO_HAVE_CALIPER@
+// clang-format on
+
 
 /* Is MPI available ? */
 // clang-format off