Merge Rename AmgxPgm to Pgm

This PR renames AmgxPgm to Pgm and deprecates AmgxPgm

Related PR: #1149

common/CMakeLists.txt

@@ -14,7 +14,7 @@ set(UNIFIED_SOURCES
     matrix/hybrid_kernels.cpp
     matrix/sellp_kernels.cpp
     matrix/diagonal_kernels.cpp
-    multigrid/amgx_pgm_kernels.cpp
+    multigrid/pgm_kernels.cpp
     preconditioner/jacobi_kernels.cpp
     solver/bicg_kernels.cpp
     solver/bicgstab_kernels.cpp

common/cuda_hip/multigrid/amgx_pgm_kernels.hpp.inc → common/cuda_hip/multigrid/pgm_kernels.hpp.inc

@@ -40,7 +40,7 @@ void sort_agg(std::shared_ptr<const DefaultExecutor> exec, IndexType num,
     thrust::sort(thrust::device, it, it + num);
 }
 
-GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_SORT_AGG_KERNEL);
+GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_PGM_SORT_AGG_KERNEL);
 
 
 template <typename ValueType, typename IndexType>
@@ -63,8 +63,7 @@ void sort_row_major(std::shared_ptr<const DefaultExecutor> exec, size_type nnz,
     thrust::sort_by_key(thrust::device, it, it + nnz, vals_it);
 }
 
-GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_SORT_ROW_MAJOR);
+GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_PGM_SORT_ROW_MAJOR);
 
 
 template <typename ValueType, typename IndexType>
@@ -94,4 +93,4 @@ void compute_coarse_coo(std::shared_ptr<const DefaultExecutor> exec,
 }
 
 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO);
+    GKO_DECLARE_PGM_COMPUTE_COARSE_COO);

common/unified/multigrid/amgx_pgm_kernels.cpp → common/unified/multigrid/pgm_kernels.cpp

@@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************<GINKGO LICENSE>*******************************/
 
-#include "core/multigrid/amgx_pgm_kernels.hpp"
+#include "core/multigrid/pgm_kernels.hpp"
 
 
 #include <ginkgo/core/base/math.hpp>
@@ -45,11 +45,11 @@ namespace gko {
 namespace kernels {
 namespace GKO_DEVICE_NAMESPACE {
 /**
- * @brief The AmgxPgm namespace.
+ * @brief The Pgm namespace.
  *
- * @ingroup amgx_pgm
+ * @ingroup pgm
  */
-namespace amgx_pgm {
+namespace pgm {
 
 
 template <typename IndexType>
@@ -75,7 +75,7 @@ void match_edge(std::shared_ptr<const DefaultExecutor> exec,
         agg.get_data());
 }
 
-GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_MATCH_EDGE_KERNEL);
+GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_PGM_MATCH_EDGE_KERNEL);
 
 
 template <typename IndexType>
@@ -91,7 +91,7 @@ void count_unagg(std::shared_ptr<const DefaultExecutor> exec,
     *num_unagg = exec->copy_val_to_host(d_result.get_const_data());
 }
 
-GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_COUNT_UNAGG_KERNEL);
+GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_PGM_COUNT_UNAGG_KERNEL);
 
 
 template <typename IndexType>
@@ -122,7 +122,7 @@ void renumber(std::shared_ptr<const DefaultExecutor> exec,
     *num_agg = exec->copy_val_to_host(agg_map.get_const_data() + num);
 }
 
-GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_RENUMBER_KERNEL);
+GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_PGM_RENUMBER_KERNEL);
 
 
 template <typename IndexType>
@@ -143,7 +143,7 @@ void map_row(std::shared_ptr<const DefaultExecutor> exec,
         num_fine_row, fine_row_ptrs, agg, row_idxs);
 }
 
-GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_MAP_ROW_KERNEL);
+GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_PGM_MAP_ROW_KERNEL);
 
 
 template <typename IndexType>
@@ -159,7 +159,7 @@ void map_col(std::shared_ptr<const DefaultExecutor> exec, size_type nnz,
         nnz, fine_col_idxs, agg, col_idxs);
 }
 
-GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_MAP_COL_KERNEL);
+GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_PGM_MAP_COL_KERNEL);
 
 
 template <typename IndexType>
@@ -185,7 +185,7 @@ void count_unrepeated_nnz(std::shared_ptr<const DefaultExecutor> exec,
 }
 
 GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_COUNT_UNREPEATED_NNZ_KERNEL);
+    GKO_DECLARE_PGM_COUNT_UNREPEATED_NNZ_KERNEL);
 
 
 template <typename ValueType, typename IndexType>
@@ -247,7 +247,7 @@ void find_strongest_neighbor(
 }
 
 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_FIND_STRONGEST_NEIGHBOR);
+    GKO_DECLARE_PGM_FIND_STRONGEST_NEIGHBOR);
 
 template <typename ValueType, typename IndexType>
 void assign_to_exist_agg(std::shared_ptr<const DefaultExecutor> exec,
@@ -333,10 +333,10 @@ void assign_to_exist_agg(std::shared_ptr<const DefaultExecutor> exec,
 }
 
 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_ASSIGN_TO_EXIST_AGG);
+    GKO_DECLARE_PGM_ASSIGN_TO_EXIST_AGG);
 
 
-}  // namespace amgx_pgm
+}  // namespace pgm
 }  // namespace GKO_DEVICE_NAMESPACE
 }  // namespace kernels
 }  // namespace gko

core/CMakeLists.txt

@@ -38,7 +38,7 @@ target_sources(ginkgo
     matrix/sellp.cpp
     matrix/sparsity_csr.cpp
     matrix/row_gatherer.cpp
-    multigrid/amgx_pgm.cpp
+    multigrid/pgm.cpp
     multigrid/fixed_coarsening.cpp
     preconditioner/isai.cpp
     preconditioner/jacobi.cpp

core/device_hooks/common_kernels.inc.cpp

@@ -63,7 +63,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "core/matrix/hybrid_kernels.hpp"
 #include "core/matrix/sellp_kernels.hpp"
 #include "core/matrix/sparsity_csr_kernels.hpp"
-#include "core/multigrid/amgx_pgm_kernels.hpp"
+#include "core/multigrid/pgm_kernels.hpp"
 #include "core/preconditioner/isai_kernels.hpp"
 #include "core/preconditioner/jacobi_kernels.hpp"
 #include "core/reorder/rcm_kernels.hpp"
@@ -758,25 +758,24 @@ GKO_STUB_INDEX_TYPE(GKO_DECLARE_RCM_GET_DEGREE_OF_NODES_KERNEL);
 }  // namespace rcm
 
 
-namespace amgx_pgm {
+namespace pgm {
 
 
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_MATCH_EDGE_KERNEL);
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_COUNT_UNAGG_KERNEL);
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_RENUMBER_KERNEL);
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_SORT_AGG_KERNEL);
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_MAP_ROW_KERNEL);
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_MAP_COL_KERNEL);
-GKO_STUB_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_COUNT_UNREPEATED_NNZ_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_MATCH_EDGE_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_COUNT_UNAGG_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_RENUMBER_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_SORT_AGG_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_MAP_ROW_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_MAP_COL_KERNEL);
+GKO_STUB_INDEX_TYPE(GKO_DECLARE_PGM_COUNT_UNREPEATED_NNZ_KERNEL);
 GKO_STUB_NON_COMPLEX_VALUE_AND_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_FIND_STRONGEST_NEIGHBOR);
-GKO_STUB_NON_COMPLEX_VALUE_AND_INDEX_TYPE(
-    GKO_DECLARE_AMGX_PGM_ASSIGN_TO_EXIST_AGG);
-GKO_STUB_VALUE_AND_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_SORT_ROW_MAJOR);
-GKO_STUB_VALUE_AND_INDEX_TYPE(GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO);
+    GKO_DECLARE_PGM_FIND_STRONGEST_NEIGHBOR);
+GKO_STUB_NON_COMPLEX_VALUE_AND_INDEX_TYPE(GKO_DECLARE_PGM_ASSIGN_TO_EXIST_AGG);
+GKO_STUB_VALUE_AND_INDEX_TYPE(GKO_DECLARE_PGM_SORT_ROW_MAJOR);
+GKO_STUB_VALUE_AND_INDEX_TYPE(GKO_DECLARE_PGM_COMPUTE_COARSE_COO);
 
 
-}  // namespace amgx_pgm
+}  // namespace pgm
 
 
 namespace set_all_statuses {

core/multigrid/amgx_pgm.cpp → core/multigrid/pgm.cpp

@@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************<GINKGO LICENSE>*******************************/
 
-#include <ginkgo/core/multigrid/amgx_pgm.hpp>
+#include <ginkgo/core/multigrid/pgm.hpp>
 
 
 #include <ginkgo/core/base/array.hpp>
@@ -51,34 +51,33 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "core/components/fill_array_kernels.hpp"
 #include "core/components/format_conversion_kernels.hpp"
 #include "core/matrix/csr_builder.hpp"
-#include "core/multigrid/amgx_pgm_kernels.hpp"
+#include "core/multigrid/pgm_kernels.hpp"
 
 
 namespace gko {
 namespace multigrid {
-namespace amgx_pgm {
+namespace pgm {
 namespace {
 
 
-GKO_REGISTER_OPERATION(match_edge, amgx_pgm::match_edge);
-GKO_REGISTER_OPERATION(count_unagg, amgx_pgm::count_unagg);
-GKO_REGISTER_OPERATION(renumber, amgx_pgm::renumber);
-GKO_REGISTER_OPERATION(find_strongest_neighbor,
-                       amgx_pgm::find_strongest_neighbor);
-GKO_REGISTER_OPERATION(assign_to_exist_agg, amgx_pgm::assign_to_exist_agg);
-GKO_REGISTER_OPERATION(sort_agg, amgx_pgm::sort_agg);
-GKO_REGISTER_OPERATION(map_row, amgx_pgm::map_row);
-GKO_REGISTER_OPERATION(map_col, amgx_pgm::map_col);
-GKO_REGISTER_OPERATION(sort_row_major, amgx_pgm::sort_row_major);
-GKO_REGISTER_OPERATION(count_unrepeated_nnz, amgx_pgm::count_unrepeated_nnz);
-GKO_REGISTER_OPERATION(compute_coarse_coo, amgx_pgm::compute_coarse_coo);
+GKO_REGISTER_OPERATION(match_edge, pgm::match_edge);
+GKO_REGISTER_OPERATION(count_unagg, pgm::count_unagg);
+GKO_REGISTER_OPERATION(renumber, pgm::renumber);
+GKO_REGISTER_OPERATION(find_strongest_neighbor, pgm::find_strongest_neighbor);
+GKO_REGISTER_OPERATION(assign_to_exist_agg, pgm::assign_to_exist_agg);
+GKO_REGISTER_OPERATION(sort_agg, pgm::sort_agg);
+GKO_REGISTER_OPERATION(map_row, pgm::map_row);
+GKO_REGISTER_OPERATION(map_col, pgm::map_col);
+GKO_REGISTER_OPERATION(sort_row_major, pgm::sort_row_major);
+GKO_REGISTER_OPERATION(count_unrepeated_nnz, pgm::count_unrepeated_nnz);
+GKO_REGISTER_OPERATION(compute_coarse_coo, pgm::compute_coarse_coo);
 GKO_REGISTER_OPERATION(fill_array, components::fill_array);
 GKO_REGISTER_OPERATION(fill_seq_array, components::fill_seq_array);
 GKO_REGISTER_OPERATION(convert_idxs_to_ptrs, components::convert_idxs_to_ptrs);
 
 
 }  // anonymous namespace
-}  // namespace amgx_pgm
+}  // namespace pgm
 
 namespace {
 
@@ -90,12 +89,12 @@ void agg_to_restrict(std::shared_ptr<const Executor> exec, IndexType num_agg,
 {
     const IndexType num = agg.get_num_elems();
     gko::array<IndexType> row_idxs(exec, agg);
-    exec->run(amgx_pgm::make_fill_seq_array(col_idxs, num));
+    exec->run(pgm::make_fill_seq_array(col_idxs, num));
     // sort the pair (int, agg) to (row_idxs, col_idxs)
-    exec->run(amgx_pgm::make_sort_agg(num, row_idxs.get_data(), col_idxs));
+    exec->run(pgm::make_sort_agg(num, row_idxs.get_data(), col_idxs));
     // row_idxs->row_ptrs
-    exec->run(amgx_pgm::make_convert_idxs_to_ptrs(row_idxs.get_data(), num,
-                                                  num_agg, row_ptrs));
+    exec->run(pgm::make_convert_idxs_to_ptrs(row_idxs.get_data(), num, num_agg,
+                                             row_ptrs));
 }
 
 
@@ -113,28 +112,26 @@ std::shared_ptr<matrix::Csr<ValueType, IndexType>> generate_coarse(
     exec->copy_from(exec.get(), nnz, fine_csr->get_const_values(),
                     vals.get_data());
     // map row_ptrs to coarse row index
-    exec->run(amgx_pgm::make_map_row(num, fine_csr->get_const_row_ptrs(),
-                                     agg.get_const_data(),
-                                     row_idxs.get_data()));
+    exec->run(pgm::make_map_row(num, fine_csr->get_const_row_ptrs(),
+                                agg.get_const_data(), row_idxs.get_data()));
     // map col_idxs to coarse col index
-    exec->run(amgx_pgm::make_map_col(nnz, fine_csr->get_const_col_idxs(),
-                                     agg.get_const_data(),
-                                     col_idxs.get_data()));
+    exec->run(pgm::make_map_col(nnz, fine_csr->get_const_col_idxs(),
+                                agg.get_const_data(), col_idxs.get_data()));
     // sort by row, col
-    exec->run(amgx_pgm::make_sort_row_major(
-        nnz, row_idxs.get_data(), col_idxs.get_data(), vals.get_data()));
+    exec->run(pgm::make_sort_row_major(nnz, row_idxs.get_data(),
+                                       col_idxs.get_data(), vals.get_data()));
     // compute the total nnz and create the fine csr
     size_type coarse_nnz = 0;
-    exec->run(amgx_pgm::make_count_unrepeated_nnz(
-        nnz, row_idxs.get_const_data(), col_idxs.get_const_data(),
-        &coarse_nnz));
+    exec->run(pgm::make_count_unrepeated_nnz(nnz, row_idxs.get_const_data(),
+                                             col_idxs.get_const_data(),
+                                             &coarse_nnz));
     // reduce by key (row, col)
     auto coarse_coo = matrix::Coo<ValueType, IndexType>::create(
         exec,
         gko::dim<2>{static_cast<size_type>(num_agg),
                     static_cast<size_type>(num_agg)},
         coarse_nnz);
-    exec->run(amgx_pgm::make_compute_coarse_coo(
+    exec->run(pgm::make_compute_coarse_coo(
         nnz, row_idxs.get_const_data(), col_idxs.get_const_data(),
         vals.get_const_data(), gko::lend(coarse_coo)));
     // use move_to
@@ -148,7 +145,7 @@ std::shared_ptr<matrix::Csr<ValueType, IndexType>> generate_coarse(
 
 
 template <typename ValueType, typename IndexType>
-void AmgxPgm<ValueType, IndexType>::generate()
+void Pgm<ValueType, IndexType>::generate()
 {
     using csr_type = matrix::Csr<ValueType, IndexType>;
     using real_type = remove_complex<ValueType>;
@@ -159,25 +156,25 @@ void AmgxPgm<ValueType, IndexType>::generate()
     array<IndexType> intermediate_agg(this->get_executor(),
                                       parameters_.deterministic * num_rows);
     // Only support csr matrix currently.
-    const csr_type* amgxpgm_op =
+    const csr_type* pgm_op =
         dynamic_cast<const csr_type*>(system_matrix_.get());
-    std::shared_ptr<const csr_type> amgxpgm_op_shared_ptr{};
+    std::shared_ptr<const csr_type> pgm_op_shared_ptr{};
     // If system matrix is not csr or need sorting, generate the csr.
-    if (!parameters_.skip_sorting || !amgxpgm_op) {
-        amgxpgm_op_shared_ptr = convert_to_with_sorting<csr_type>(
+    if (!parameters_.skip_sorting || !pgm_op) {
+        pgm_op_shared_ptr = convert_to_with_sorting<csr_type>(
             exec, system_matrix_, parameters_.skip_sorting);
-        amgxpgm_op = amgxpgm_op_shared_ptr.get();
+        pgm_op = pgm_op_shared_ptr.get();
         // keep the same precision data in fine_op
-        this->set_fine_op(amgxpgm_op_shared_ptr);
+        this->set_fine_op(pgm_op_shared_ptr);
     }
     // Initial agg = -1
-    exec->run(amgx_pgm::make_fill_array(agg_.get_data(), agg_.get_num_elems(),
-                                        -one<IndexType>()));
+    exec->run(pgm::make_fill_array(agg_.get_data(), agg_.get_num_elems(),
+                                   -one<IndexType>()));
     IndexType num_unagg = num_rows;
     IndexType num_unagg_prev = num_rows;
     // TODO: if mtx is a hermitian matrix, weight_mtx = abs(mtx)
     // compute weight_mtx = (abs(mtx) + abs(mtx'))/2;
-    auto abs_mtx = amgxpgm_op->compute_absolute();
+    auto abs_mtx = pgm_op->compute_absolute();
     // abs_mtx is already real valuetype, so transpose is enough
     auto weight_mtx = gko::as<weight_csr_type>(abs_mtx->transpose());
     auto half_scalar = initialize<matrix::Dense<real_type>>({0.5}, exec);
@@ -189,12 +186,12 @@ void AmgxPgm<ValueType, IndexType>::generate()
     auto diag = weight_mtx->extract_diagonal();
     for (int i = 0; i < parameters_.max_iterations; i++) {
         // Find the strongest neighbor of each row
-        exec->run(amgx_pgm::make_find_strongest_neighbor(
+        exec->run(pgm::make_find_strongest_neighbor(
             weight_mtx.get(), diag.get(), agg_, strongest_neighbor));
         // Match edges
-        exec->run(amgx_pgm::make_match_edge(strongest_neighbor, agg_));
+        exec->run(pgm::make_match_edge(strongest_neighbor, agg_));
         // Get the num_unagg
-        exec->run(amgx_pgm::make_count_unagg(agg_, &num_unagg));
+        exec->run(pgm::make_count_unagg(agg_, &num_unagg));
         // no new match, all match, or the ratio of num_unagg/num is lower
         // than parameter.max_unassigned_ratio
         if (num_unagg == 0 || num_unagg == num_unagg_prev ||
@@ -210,12 +207,12 @@ void AmgxPgm<ValueType, IndexType>::generate()
     }
     if (num_unagg != 0) {
         // Assign all left points
-        exec->run(amgx_pgm::make_assign_to_exist_agg(
-            weight_mtx.get(), diag.get(), agg_, intermediate_agg));
+        exec->run(pgm::make_assign_to_exist_agg(weight_mtx.get(), diag.get(),
+                                                agg_, intermediate_agg));
     }
     IndexType num_agg = 0;
     // Renumber the index
-    exec->run(amgx_pgm::make_renumber(agg_, &num_agg));
+    exec->run(pgm::make_renumber(agg_, &num_agg));
 
     gko::dim<2>::dimension_type coarse_dim = num_agg;
     auto fine_dim = system_matrix_->get_size()[0];
@@ -232,15 +229,15 @@ void AmgxPgm<ValueType, IndexType>::generate()
 
     // Construct the coarse matrix
     // TODO: improve it
-    auto coarse_matrix = generate_coarse(exec, amgxpgm_op, num_agg, agg_);
+    auto coarse_matrix = generate_coarse(exec, pgm_op, num_agg, agg_);
 
     this->set_multigrid_level(prolong_row_gather, coarse_matrix,
                               restrict_sparsity);
 }
 
 
-#define GKO_DECLARE_AMGX_PGM(_vtype, _itype) class AmgxPgm<_vtype, _itype>
-GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_AMGX_PGM);
+#define GKO_DECLARE_PGM(_vtype, _itype) class Pgm<_vtype, _itype>
+GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_PGM);
 
 
 }  // namespace multigrid