diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 04f33b4a718..e84705672b8 100644 --- a/common/CMakeLists.txt +++ b/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 diff --git a/common/cuda_hip/multigrid/amgx_pgm_kernels.hpp.inc b/common/cuda_hip/multigrid/pgm_kernels.hpp.inc similarity index 95% rename from common/cuda_hip/multigrid/amgx_pgm_kernels.hpp.inc rename to common/cuda_hip/multigrid/pgm_kernels.hpp.inc index 0a16abc2dcc..af898965faf 100644 --- a/common/cuda_hip/multigrid/amgx_pgm_kernels.hpp.inc +++ b/common/cuda_hip/multigrid/pgm_kernels.hpp.inc @@ -40,7 +40,7 @@ void sort_agg(std::shared_ptr 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 @@ -63,8 +63,7 @@ void sort_row_major(std::shared_ptr 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 @@ -94,4 +93,4 @@ void compute_coarse_coo(std::shared_ptr exec, } GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( - GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO); + GKO_DECLARE_PGM_COMPUTE_COARSE_COO); diff --git a/common/unified/multigrid/amgx_pgm_kernels.cpp b/common/unified/multigrid/pgm_kernels.cpp similarity index 94% rename from common/unified/multigrid/amgx_pgm_kernels.cpp rename to common/unified/multigrid/pgm_kernels.cpp index 94a0f8819ed..5b237337d60 100644 --- a/common/unified/multigrid/amgx_pgm_kernels.cpp +++ b/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. *************************************************************/ -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -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 @@ -75,7 +75,7 @@ void match_edge(std::shared_ptr 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 @@ -91,7 +91,7 @@ void count_unagg(std::shared_ptr 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 @@ -122,7 +122,7 @@ void renumber(std::shared_ptr 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 @@ -143,7 +143,7 @@ void map_row(std::shared_ptr 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 @@ -159,7 +159,7 @@ void map_col(std::shared_ptr 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 @@ -185,7 +185,7 @@ void count_unrepeated_nnz(std::shared_ptr exec, } GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE( - GKO_DECLARE_AMGX_PGM_COUNT_UNREPEATED_NNZ_KERNEL); + GKO_DECLARE_PGM_COUNT_UNREPEATED_NNZ_KERNEL); template @@ -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 void assign_to_exist_agg(std::shared_ptr exec, @@ -333,10 +333,10 @@ void assign_to_exist_agg(std::shared_ptr 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 diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt index 4a42610371d..427ac8091a3 100644 --- a/core/CMakeLists.txt +++ b/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 diff --git a/core/device_hooks/common_kernels.inc.cpp b/core/device_hooks/common_kernels.inc.cpp index 474d7b9f95a..83f6628404e 100644 --- a/core/device_hooks/common_kernels.inc.cpp +++ b/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 { diff --git a/core/multigrid/amgx_pgm.cpp b/core/multigrid/pgm.cpp similarity index 72% rename from core/multigrid/amgx_pgm.cpp rename to core/multigrid/pgm.cpp index f0bd5262aba..a551baf728e 100644 --- a/core/multigrid/amgx_pgm.cpp +++ b/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. *************************************************************/ -#include +#include #include @@ -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 exec, IndexType num_agg, { const IndexType num = agg.get_num_elems(); gko::array 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> 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::create( exec, gko::dim<2>{static_cast(num_agg), static_cast(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> generate_coarse( template -void AmgxPgm::generate() +void Pgm::generate() { using csr_type = matrix::Csr; using real_type = remove_complex; @@ -159,25 +156,25 @@ void AmgxPgm::generate() array 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(system_matrix_.get()); - std::shared_ptr amgxpgm_op_shared_ptr{}; + std::shared_ptr 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( + if (!parameters_.skip_sorting || !pgm_op) { + pgm_op_shared_ptr = convert_to_with_sorting( 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())); + exec->run(pgm::make_fill_array(agg_.get_data(), agg_.get_num_elems(), + -one())); 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(abs_mtx->transpose()); auto half_scalar = initialize>({0.5}, exec); @@ -189,12 +186,12 @@ void AmgxPgm::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::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::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 diff --git a/core/multigrid/amgx_pgm_kernels.hpp b/core/multigrid/pgm_kernels.hpp similarity index 72% rename from core/multigrid/amgx_pgm_kernels.hpp rename to core/multigrid/pgm_kernels.hpp index d64fd05b5fd..b712d8b2ff3 100644 --- a/core/multigrid/amgx_pgm_kernels.hpp +++ b/core/multigrid/pgm_kernels.hpp @@ -30,11 +30,11 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#ifndef GKO_CORE_MULTIGRID_AMGX_PGM_KERNELS_HPP_ -#define GKO_CORE_MULTIGRID_AMGX_PGM_KERNELS_HPP_ +#ifndef GKO_CORE_MULTIGRID_PGM_KERNELS_HPP_ +#define GKO_CORE_MULTIGRID_PGM_KERNELS_HPP_ -#include +#include #include @@ -52,97 +52,97 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace gko { namespace kernels { -namespace amgx_pgm { +namespace pgm { -#define GKO_DECLARE_AMGX_PGM_MATCH_EDGE_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_MATCH_EDGE_KERNEL(IndexType) \ void match_edge(std::shared_ptr exec, \ const array& strongest_neighbor, \ array& agg) -#define GKO_DECLARE_AMGX_PGM_COUNT_UNAGG_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_COUNT_UNAGG_KERNEL(IndexType) \ void count_unagg(std::shared_ptr exec, \ const array& agg, IndexType* num_unagg) -#define GKO_DECLARE_AMGX_PGM_RENUMBER_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_RENUMBER_KERNEL(IndexType) \ void renumber(std::shared_ptr exec, \ array& agg, IndexType* num_agg) -#define GKO_DECLARE_AMGX_PGM_SORT_AGG_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_SORT_AGG_KERNEL(IndexType) \ void sort_agg(std::shared_ptr exec, IndexType num, \ IndexType* row_idxs, IndexType* col_idxs) -#define GKO_DECLARE_AMGX_PGM_MAP_ROW_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_MAP_ROW_KERNEL(IndexType) \ void map_row(std::shared_ptr exec, \ size_type num_fine_row, const IndexType* fine_row_ptrs, \ const IndexType* agg, IndexType* row_idxs) -#define GKO_DECLARE_AMGX_PGM_MAP_COL_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_MAP_COL_KERNEL(IndexType) \ void map_col(std::shared_ptr exec, size_type nnz, \ const IndexType* fine_col_idxs, const IndexType* agg, \ IndexType* col_idxs) -#define GKO_DECLARE_AMGX_PGM_COUNT_UNREPEATED_NNZ_KERNEL(IndexType) \ +#define GKO_DECLARE_PGM_COUNT_UNREPEATED_NNZ_KERNEL(IndexType) \ void count_unrepeated_nnz(std::shared_ptr exec, \ size_type nnz, const IndexType* row_idxs, \ const IndexType* col_idxs, \ size_type* coarse_nnz) -#define GKO_DECLARE_AMGX_PGM_FIND_STRONGEST_NEIGHBOR(ValueType, IndexType) \ - void find_strongest_neighbor( \ - std::shared_ptr exec, \ - const matrix::Csr* weight_mtx, \ - const matrix::Diagonal* diag, array& agg, \ +#define GKO_DECLARE_PGM_FIND_STRONGEST_NEIGHBOR(ValueType, IndexType) \ + void find_strongest_neighbor( \ + std::shared_ptr exec, \ + const matrix::Csr* weight_mtx, \ + const matrix::Diagonal* diag, array& agg, \ array& strongest_neighbor) -#define GKO_DECLARE_AMGX_PGM_ASSIGN_TO_EXIST_AGG(ValueType, IndexType) \ +#define GKO_DECLARE_PGM_ASSIGN_TO_EXIST_AGG(ValueType, IndexType) \ void assign_to_exist_agg( \ std::shared_ptr exec, \ const matrix::Csr* weight_mtx, \ const matrix::Diagonal* diag, array& agg, \ array& intermediate_agg) -#define GKO_DECLARE_AMGX_PGM_SORT_ROW_MAJOR(ValueType, IndexType) \ +#define GKO_DECLARE_PGM_SORT_ROW_MAJOR(ValueType, IndexType) \ void sort_row_major(std::shared_ptr exec, \ size_type nnz, IndexType* row_idxs, \ IndexType* col_idxs, ValueType* vals) -#define GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO(ValueType, IndexType) \ +#define GKO_DECLARE_PGM_COMPUTE_COARSE_COO(ValueType, IndexType) \ void compute_coarse_coo(std::shared_ptr exec, \ size_type fine_nnz, const IndexType* row_idxs, \ const IndexType* col_idxs, const ValueType* vals, \ matrix::Coo* coarse_coo) -#define GKO_DECLARE_ALL_AS_TEMPLATES \ - template \ - GKO_DECLARE_AMGX_PGM_MATCH_EDGE_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_COUNT_UNAGG_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_RENUMBER_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_SORT_AGG_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_MAP_ROW_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_MAP_COL_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_COUNT_UNREPEATED_NNZ_KERNEL(IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_FIND_STRONGEST_NEIGHBOR(ValueType, IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_ASSIGN_TO_EXIST_AGG(ValueType, IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_SORT_ROW_MAJOR(ValueType, IndexType); \ - template \ - GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO(ValueType, IndexType) +#define GKO_DECLARE_ALL_AS_TEMPLATES \ + template \ + GKO_DECLARE_PGM_MATCH_EDGE_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_COUNT_UNAGG_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_RENUMBER_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_SORT_AGG_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_MAP_ROW_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_MAP_COL_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_COUNT_UNREPEATED_NNZ_KERNEL(IndexType); \ + template \ + GKO_DECLARE_PGM_FIND_STRONGEST_NEIGHBOR(ValueType, IndexType); \ + template \ + GKO_DECLARE_PGM_ASSIGN_TO_EXIST_AGG(ValueType, IndexType); \ + template \ + GKO_DECLARE_PGM_SORT_ROW_MAJOR(ValueType, IndexType); \ + template \ + GKO_DECLARE_PGM_COMPUTE_COARSE_COO(ValueType, IndexType) -} // namespace amgx_pgm +} // namespace pgm -GKO_DECLARE_FOR_ALL_EXECUTOR_NAMESPACES(amgx_pgm, GKO_DECLARE_ALL_AS_TEMPLATES); +GKO_DECLARE_FOR_ALL_EXECUTOR_NAMESPACES(pgm, GKO_DECLARE_ALL_AS_TEMPLATES); #undef GKO_DECLARE_ALL_AS_TEMPLATES @@ -152,4 +152,4 @@ GKO_DECLARE_FOR_ALL_EXECUTOR_NAMESPACES(amgx_pgm, GKO_DECLARE_ALL_AS_TEMPLATES); } // namespace gko -#endif // GKO_CORE_MULTIGRID_AMGX_PGM_KERNELS_HPP_ +#endif // GKO_CORE_MULTIGRID_PGM_KERNELS_HPP_ diff --git a/core/test/multigrid/CMakeLists.txt b/core/test/multigrid/CMakeLists.txt index fe9ac77cfb9..a6a230aca5c 100644 --- a/core/test/multigrid/CMakeLists.txt +++ b/core/test/multigrid/CMakeLists.txt @@ -1,2 +1,2 @@ -ginkgo_create_test(amgx_pgm) +ginkgo_create_test(pgm) ginkgo_create_test(fixed_coarsening) diff --git a/core/test/multigrid/amgx_pgm.cpp b/core/test/multigrid/pgm.cpp similarity index 67% rename from core/test/multigrid/amgx_pgm.cpp rename to core/test/multigrid/pgm.cpp index e2b0b6d0dea..a9e3b162bbe 100644 --- a/core/test/multigrid/amgx_pgm.cpp +++ b/core/test/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. *************************************************************/ -#include +#include #include @@ -49,7 +49,7 @@ namespace { template -class AmgxPgmFactory : public ::testing::Test { +class PgmFactory : public ::testing::Test { protected: using value_type = typename std::tuple_element<0, decltype(ValueIndexType())>::type; @@ -57,33 +57,33 @@ class AmgxPgmFactory : public ::testing::Test { typename std::tuple_element<1, decltype(ValueIndexType())>::type; using Mtx = gko::matrix::Csr; using Vec = gko::matrix::Dense; - using MgLevel = gko::multigrid::AmgxPgm; - AmgxPgmFactory() + using MgLevel = gko::multigrid::Pgm; + PgmFactory() : exec(gko::ReferenceExecutor::create()), - amgxpgm_factory(MgLevel::build() - .with_max_iterations(2u) - .with_max_unassigned_ratio(0.1) - .with_deterministic(true) - .with_skip_sorting(true) - .on(exec)) + pgm_factory(MgLevel::build() + .with_max_iterations(2u) + .with_max_unassigned_ratio(0.1) + .with_deterministic(true) + .with_skip_sorting(true) + .on(exec)) {} std::shared_ptr exec; - std::unique_ptr amgxpgm_factory; + std::unique_ptr pgm_factory; }; -TYPED_TEST_SUITE(AmgxPgmFactory, gko::test::ValueIndexTypes, +TYPED_TEST_SUITE(PgmFactory, gko::test::ValueIndexTypes, PairTypenameNameGenerator); -TYPED_TEST(AmgxPgmFactory, FactoryKnowsItsExecutor) +TYPED_TEST(PgmFactory, FactoryKnowsItsExecutor) { - ASSERT_EQ(this->amgxpgm_factory->get_executor(), this->exec); + ASSERT_EQ(this->pgm_factory->get_executor(), this->exec); } -TYPED_TEST(AmgxPgmFactory, DefaultSetting) +TYPED_TEST(PgmFactory, DefaultSetting) { using MgLevel = typename TestFixture::MgLevel; auto factory = MgLevel::build().on(this->exec); @@ -95,28 +95,27 @@ TYPED_TEST(AmgxPgmFactory, DefaultSetting) } -TYPED_TEST(AmgxPgmFactory, SetMaxIterations) +TYPED_TEST(PgmFactory, SetMaxIterations) { - ASSERT_EQ(this->amgxpgm_factory->get_parameters().max_iterations, 2u); + ASSERT_EQ(this->pgm_factory->get_parameters().max_iterations, 2u); } -TYPED_TEST(AmgxPgmFactory, SetMaxUnassignedPercentage) +TYPED_TEST(PgmFactory, SetMaxUnassignedPercentage) { - ASSERT_EQ(this->amgxpgm_factory->get_parameters().max_unassigned_ratio, - 0.1); + ASSERT_EQ(this->pgm_factory->get_parameters().max_unassigned_ratio, 0.1); } -TYPED_TEST(AmgxPgmFactory, SetDeterministic) +TYPED_TEST(PgmFactory, SetDeterministic) { - ASSERT_EQ(this->amgxpgm_factory->get_parameters().deterministic, true); + ASSERT_EQ(this->pgm_factory->get_parameters().deterministic, true); } -TYPED_TEST(AmgxPgmFactory, SetSkipSorting) +TYPED_TEST(PgmFactory, SetSkipSorting) { - ASSERT_EQ(this->amgxpgm_factory->get_parameters().skip_sorting, true); + ASSERT_EQ(this->pgm_factory->get_parameters().skip_sorting, true); } diff --git a/cuda/CMakeLists.txt b/cuda/CMakeLists.txt index 0035b383ae9..11a91936679 100644 --- a/cuda/CMakeLists.txt +++ b/cuda/CMakeLists.txt @@ -31,7 +31,7 @@ target_sources(ginkgo_cuda matrix/fft_kernels.cu matrix/sellp_kernels.cu matrix/sparsity_csr_kernels.cu - multigrid/amgx_pgm_kernels.cu + multigrid/pgm_kernels.cu preconditioner/isai_kernels.cu preconditioner/jacobi_advanced_apply_kernel.cu preconditioner/jacobi_generate_kernel.cu diff --git a/cuda/multigrid/amgx_pgm_kernels.cu b/cuda/multigrid/pgm_kernels.cu similarity index 88% rename from cuda/multigrid/amgx_pgm_kernels.cu rename to cuda/multigrid/pgm_kernels.cu index 70cf46122fb..0a5dfb452ba 100644 --- a/cuda/multigrid/amgx_pgm_kernels.cu +++ b/cuda/multigrid/pgm_kernels.cu @@ -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. *************************************************************/ -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include +#include #include "cuda/base/types.hpp" @@ -57,17 +57,17 @@ namespace gko { namespace kernels { namespace cuda { /** - * @brief The AMGX_PGM solver namespace. + * @brief The PGM solver namespace. * - * @ingroup amgx_pgm + * @ingroup pgm */ -namespace amgx_pgm { +namespace pgm { -#include "common/cuda_hip/multigrid/amgx_pgm_kernels.hpp.inc" +#include "common/cuda_hip/multigrid/pgm_kernels.hpp.inc" -} // namespace amgx_pgm +} // namespace pgm } // namespace cuda } // namespace kernels } // namespace gko diff --git a/dpcpp/CMakeLists.txt b/dpcpp/CMakeLists.txt index 3c8c9bec1c0..55b8dd87022 100644 --- a/dpcpp/CMakeLists.txt +++ b/dpcpp/CMakeLists.txt @@ -39,7 +39,7 @@ target_sources(ginkgo_dpcpp matrix/fft_kernels.dp.cpp matrix/sellp_kernels.dp.cpp matrix/sparsity_csr_kernels.dp.cpp - multigrid/amgx_pgm_kernels.dp.cpp + multigrid/pgm_kernels.dp.cpp preconditioner/isai_kernels.dp.cpp preconditioner/jacobi_kernels.dp.cpp reorder/rcm_kernels.dp.cpp diff --git a/dpcpp/multigrid/amgx_pgm_kernels.dp.cpp b/dpcpp/multigrid/pgm_kernels.dp.cpp similarity index 91% rename from dpcpp/multigrid/amgx_pgm_kernels.dp.cpp rename to dpcpp/multigrid/pgm_kernels.dp.cpp index f87017c9412..4cb29304d61 100644 --- a/dpcpp/multigrid/amgx_pgm_kernels.dp.cpp +++ b/dpcpp/multigrid/pgm_kernels.dp.cpp @@ -37,7 +37,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // force-top: off -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -45,18 +45,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include +#include namespace gko { namespace kernels { namespace dpcpp { /** - * @brief The AMGX_PGM solver namespace. + * @brief The PGM solver namespace. * - * @ingroup amgx_pgm + * @ingroup pgm */ -namespace amgx_pgm { +namespace pgm { template @@ -72,7 +72,7 @@ void sort_agg(std::shared_ptr exec, IndexType 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 @@ -91,8 +91,7 @@ void sort_row_major(std::shared_ptr exec, size_type nnz, }); } -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 @@ -126,10 +125,10 @@ void compute_coarse_coo(std::shared_ptr exec, } GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( - GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO); + GKO_DECLARE_PGM_COMPUTE_COARSE_COO); -} // namespace amgx_pgm +} // namespace pgm } // namespace dpcpp } // namespace kernels } // namespace gko diff --git a/examples/mixed-multigrid-solver/mixed-multigrid-solver.cpp b/examples/mixed-multigrid-solver/mixed-multigrid-solver.cpp index 151d3796c20..371b878c4ff 100644 --- a/examples/mixed-multigrid-solver/mixed-multigrid-solver.cpp +++ b/examples/mixed-multigrid-solver/mixed-multigrid-solver.cpp @@ -56,8 +56,8 @@ int main(int argc, char* argv[]) using mg = gko::solver::Multigrid; using bj = gko::preconditioner::Jacobi; using bj2 = gko::preconditioner::Jacobi; - using amgx_pgm = gko::multigrid::AmgxPgm; - using amgx_pgm2 = gko::multigrid::AmgxPgm; + using pgm = gko::multigrid::Pgm; + using pgm2 = gko::multigrid::Pgm; // Print version information std::cout << gko::version_info::get() << std::endl; @@ -143,9 +143,9 @@ int main(int argc, char* argv[]) .on(exec)); // Create RestrictProlong factory auto mg_level_gen = - gko::share(amgx_pgm::build().with_deterministic(true).on(exec)); + gko::share(pgm::build().with_deterministic(true).on(exec)); auto mg_level_gen2 = - gko::share(amgx_pgm2::build().with_deterministic(true).on(exec)); + gko::share(pgm2::build().with_deterministic(true).on(exec)); // Create CoarsesSolver factory auto coarsest_solver_gen = cg::build() @@ -197,8 +197,8 @@ int main(int argc, char* argv[]) auto smoother_list = solver->get_pre_smoother_list(); // Check the MultigridLevel and smoother. // throw error if there is mismatch - auto level0 = gko::as(mg_level_list.at(0)); - auto level1 = gko::as(mg_level_list.at(1)); + auto level0 = gko::as(mg_level_list.at(0)); + auto level1 = gko::as(mg_level_list.at(1)); auto smoother0 = gko::as(smoother_list.at(0)); auto smoother1 = gko::as(smoother_list.at(1)); diff --git a/examples/multigrid-preconditioned-solver/multigrid-preconditioned-solver.cpp b/examples/multigrid-preconditioned-solver/multigrid-preconditioned-solver.cpp index 017678137c9..dce8935b0ac 100644 --- a/examples/multigrid-preconditioned-solver/multigrid-preconditioned-solver.cpp +++ b/examples/multigrid-preconditioned-solver/multigrid-preconditioned-solver.cpp @@ -53,7 +53,7 @@ int main(int argc, char* argv[]) using ir = gko::solver::Ir; using mg = gko::solver::Multigrid; using bj = gko::preconditioner::Jacobi; - using amgx_pgm = gko::multigrid::AmgxPgm; + using pgm = gko::multigrid::Pgm; // Print version information std::cout << gko::version_info::get() << std::endl; @@ -134,7 +134,7 @@ int main(int argc, char* argv[]) .on(exec)); // Create MultigridLevel factory auto mg_level_gen = - gko::share(amgx_pgm::build().with_deterministic(true).on(exec)); + gko::share(pgm::build().with_deterministic(true).on(exec)); // Create CoarsestSolver factory auto coarsest_gen = gko::share( ir::build() diff --git a/hip/CMakeLists.txt b/hip/CMakeLists.txt index 0567816b651..3300e73b483 100644 --- a/hip/CMakeLists.txt +++ b/hip/CMakeLists.txt @@ -28,7 +28,7 @@ set(GINKGO_HIP_SOURCES matrix/fbcsr_kernels.hip.cpp matrix/sellp_kernels.hip.cpp matrix/sparsity_csr_kernels.hip.cpp - multigrid/amgx_pgm_kernels.hip.cpp + multigrid/pgm_kernels.hip.cpp preconditioner/isai_kernels.hip.cpp preconditioner/jacobi_advanced_apply_kernel.hip.cpp preconditioner/jacobi_generate_kernel.hip.cpp diff --git a/hip/multigrid/amgx_pgm_kernels.hip.cpp b/hip/multigrid/pgm_kernels.hip.cpp similarity index 88% rename from hip/multigrid/amgx_pgm_kernels.hip.cpp rename to hip/multigrid/pgm_kernels.hip.cpp index eff648aa163..062d3818c87 100644 --- a/hip/multigrid/amgx_pgm_kernels.hip.cpp +++ b/hip/multigrid/pgm_kernels.hip.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. *************************************************************/ -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include +#include #include "hip/base/types.hip.hpp" @@ -55,17 +55,17 @@ namespace gko { namespace kernels { namespace hip { /** - * @brief The AMGX_PGM solver namespace. + * @brief The PGM solver namespace. * - * @ingroup amgx_pgm + * @ingroup pgm */ -namespace amgx_pgm { +namespace pgm { -#include "common/cuda_hip/multigrid/amgx_pgm_kernels.hpp.inc" +#include "common/cuda_hip/multigrid/pgm_kernels.hpp.inc" -} // namespace amgx_pgm +} // namespace pgm } // namespace hip } // namespace kernels } // namespace gko diff --git a/include/ginkgo/core/multigrid/amgx_pgm.hpp b/include/ginkgo/core/multigrid/pgm.hpp similarity index 84% rename from include/ginkgo/core/multigrid/amgx_pgm.hpp rename to include/ginkgo/core/multigrid/pgm.hpp index 1c68a2797e2..875d558f6f5 100644 --- a/include/ginkgo/core/multigrid/amgx_pgm.hpp +++ b/include/ginkgo/core/multigrid/pgm.hpp @@ -30,8 +30,8 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#ifndef GKO_PUBLIC_CORE_MULTIGRID_AMGX_PGM_HPP_ -#define GKO_PUBLIC_CORE_MULTIGRID_AMGX_PGM_HPP_ +#ifndef GKO_PUBLIC_CORE_MULTIGRID_PGM_HPP_ +#define GKO_PUBLIC_CORE_MULTIGRID_PGM_HPP_ #include @@ -50,13 +50,13 @@ namespace multigrid { /** - * Amgx parallel graph match (AmgxPgm) is the aggregate method introduced in the + * Parallel graph match (Pgm) is the aggregate method introduced in the * paper M. Naumov et al., "AmgX: A Library for GPU Accelerated Algebraic * Multigrid and Preconditioned Iterative Methods". Current implementation only * contains size = 2 version. * - * AmgxPgm creates the aggregate group according to the matrix value not the - * structure. AmgxPgm gives two steps (one-phase handshaking) to group the + * Pgm creates the aggregate group according to the matrix value not the + * structure. Pgm gives two steps (one-phase handshaking) to group the * elements. * 1: get the strongest neighbor of each unaggregated element. * 2: group the elements whose strongest neighbor is each other. @@ -72,10 +72,10 @@ namespace multigrid { * @ingroup LinOp */ template -class AmgxPgm : public EnableLinOp>, - public EnableMultigridLevel { - friend class EnableLinOp; - friend class EnablePolymorphicObject; +class Pgm : public EnableLinOp>, + public EnableMultigridLevel { + friend class EnableLinOp; + friend class EnablePolymorphicObject; public: using value_type = ValueType; @@ -103,7 +103,7 @@ class AmgxPgm : public EnableLinOp>, IndexType* get_agg() noexcept { return agg_.get_data(); } /** - * @copydoc AmgxPgm::get_agg() + * @copydoc Pgm::get_agg() * * @note This is the constant version of the function, which can be * significantly more memory efficient than the non-constant version, @@ -152,7 +152,7 @@ class AmgxPgm : public EnableLinOp>, */ bool GKO_FACTORY_PARAMETER_SCALAR(skip_sorting, false); }; - GKO_ENABLE_LIN_OP_FACTORY(AmgxPgm, parameters, Factory); + GKO_ENABLE_LIN_OP_FACTORY(Pgm, parameters, Factory); GKO_ENABLE_BUILD_METHOD(Factory); protected: @@ -167,14 +167,13 @@ class AmgxPgm : public EnableLinOp>, this->get_composition()->apply(alpha, b, beta, x); } - explicit AmgxPgm(std::shared_ptr exec) - : EnableLinOp(std::move(exec)) + explicit Pgm(std::shared_ptr exec) + : EnableLinOp(std::move(exec)) {} - explicit AmgxPgm(const Factory* factory, - std::shared_ptr system_matrix) - : EnableLinOp(factory->get_executor(), - system_matrix->get_size()), + explicit Pgm(const Factory* factory, + std::shared_ptr system_matrix) + : EnableLinOp(factory->get_executor(), system_matrix->get_size()), EnableMultigridLevel(system_matrix), parameters_{factory->get_parameters()}, system_matrix_{system_matrix}, @@ -196,8 +195,15 @@ class AmgxPgm : public EnableLinOp>, }; +template +using AmgxPgm + [[deprecated("This class is deprecated and will be removed in the next " + "major release. Please use Pgm instead.")]] = + Pgm; + + } // namespace multigrid } // namespace gko -#endif // GKO_PUBLIC_CORE_MULTIGRID_AMGX_PGM_HPP_ +#endif // GKO_PUBLIC_CORE_MULTIGRID_PGM_HPP_ diff --git a/include/ginkgo/ginkgo.hpp b/include/ginkgo/ginkgo.hpp index c5dc667a3ec..03ba363c69d 100644 --- a/include/ginkgo/ginkgo.hpp +++ b/include/ginkgo/ginkgo.hpp @@ -100,9 +100,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include #include #include +#include #include #include diff --git a/omp/CMakeLists.txt b/omp/CMakeLists.txt index 0f52ecce468..8704b7bb3b3 100644 --- a/omp/CMakeLists.txt +++ b/omp/CMakeLists.txt @@ -24,7 +24,7 @@ target_sources(ginkgo_omp matrix/fft_kernels.cpp matrix/sellp_kernels.cpp matrix/sparsity_csr_kernels.cpp - multigrid/amgx_pgm_kernels.cpp + multigrid/pgm_kernels.cpp preconditioner/isai_kernels.cpp preconditioner/jacobi_kernels.cpp reorder/rcm_kernels.cpp diff --git a/omp/multigrid/amgx_pgm_kernels.cpp b/omp/multigrid/pgm_kernels.cpp similarity index 90% rename from omp/multigrid/amgx_pgm_kernels.cpp rename to omp/multigrid/pgm_kernels.cpp index 9943f4f2c31..6639eefed0b 100644 --- a/omp/multigrid/amgx_pgm_kernels.cpp +++ b/omp/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. *************************************************************/ -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include +#include #include "core/base/iterator_factory.hpp" @@ -52,11 +52,11 @@ namespace gko { namespace kernels { namespace omp { /** - * @brief The AMGX_PGM solver namespace. + * @brief The PGM solver namespace. * - * @ingroup amgx_pgm + * @ingroup pgm */ -namespace amgx_pgm { +namespace pgm { template @@ -67,7 +67,7 @@ void sort_agg(std::shared_ptr exec, IndexType num, std::sort(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 @@ -81,8 +81,7 @@ void sort_row_major(std::shared_ptr exec, size_type nnz, }); } -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 @@ -119,10 +118,10 @@ void compute_coarse_coo(std::shared_ptr exec, } GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( - GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO); + GKO_DECLARE_PGM_COMPUTE_COARSE_COO); -} // namespace amgx_pgm +} // namespace pgm } // namespace omp } // namespace kernels } // namespace gko diff --git a/reference/CMakeLists.txt b/reference/CMakeLists.txt index 05952a118e1..4733fe228d2 100644 --- a/reference/CMakeLists.txt +++ b/reference/CMakeLists.txt @@ -30,7 +30,7 @@ target_sources(ginkgo_reference matrix/hybrid_kernels.cpp matrix/sellp_kernels.cpp matrix/sparsity_csr_kernels.cpp - multigrid/amgx_pgm_kernels.cpp + multigrid/pgm_kernels.cpp preconditioner/isai_kernels.cpp preconditioner/jacobi_kernels.cpp reorder/rcm_kernels.cpp diff --git a/reference/multigrid/amgx_pgm_kernels.cpp b/reference/multigrid/pgm_kernels.cpp similarity index 92% rename from reference/multigrid/amgx_pgm_kernels.cpp rename to reference/multigrid/pgm_kernels.cpp index 8369e2fb983..94a48fadbed 100644 --- a/reference/multigrid/amgx_pgm_kernels.cpp +++ b/reference/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. *************************************************************/ -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#include #include "core/base/allocator.hpp" @@ -57,11 +57,11 @@ namespace gko { namespace kernels { namespace reference { /** - * @brief The AMGX_PGM solver namespace. + * @brief The PGM solver namespace. * - * @ingroup amgx_pgm + * @ingroup pgm */ -namespace amgx_pgm { +namespace pgm { template @@ -85,7 +85,7 @@ void match_edge(std::shared_ptr exec, } } -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 @@ -99,7 +99,7 @@ void count_unagg(std::shared_ptr exec, *num_unagg = unagg; } -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 @@ -123,7 +123,7 @@ void renumber(std::shared_ptr exec, *num_agg = agg_map_vals[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 @@ -134,7 +134,7 @@ void sort_agg(std::shared_ptr exec, IndexType num, std::sort(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 @@ -150,7 +150,7 @@ void map_row(std::shared_ptr exec, } } -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 @@ -163,7 +163,7 @@ void map_col(std::shared_ptr exec, size_type nnz, } } -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 @@ -186,7 +186,7 @@ void count_unrepeated_nnz(std::shared_ptr exec, } GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE( - GKO_DECLARE_AMGX_PGM_COUNT_UNREPEATED_NNZ_KERNEL); + GKO_DECLARE_PGM_COUNT_UNREPEATED_NNZ_KERNEL); template @@ -241,7 +241,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 @@ -293,7 +293,7 @@ void assign_to_exist_agg(std::shared_ptr 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); template @@ -307,8 +307,7 @@ void sort_row_major(std::shared_ptr exec, size_type nnz, }); } -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 @@ -346,10 +345,10 @@ void compute_coarse_coo(std::shared_ptr exec, } GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( - GKO_DECLARE_AMGX_PGM_COMPUTE_COARSE_COO); + GKO_DECLARE_PGM_COMPUTE_COARSE_COO); -} // namespace amgx_pgm +} // namespace pgm } // namespace reference } // namespace kernels } // namespace gko diff --git a/reference/test/multigrid/CMakeLists.txt b/reference/test/multigrid/CMakeLists.txt index ad140082d6a..9853a468df6 100644 --- a/reference/test/multigrid/CMakeLists.txt +++ b/reference/test/multigrid/CMakeLists.txt @@ -1,2 +1,2 @@ -ginkgo_create_test(amgx_pgm_kernels) +ginkgo_create_test(pgm_kernels) ginkgo_create_test(fixed_coarsening_kernels) diff --git a/reference/test/multigrid/amgx_pgm_kernels.cpp b/reference/test/multigrid/pgm_kernels.cpp similarity index 86% rename from reference/test/multigrid/amgx_pgm_kernels.cpp rename to reference/test/multigrid/pgm_kernels.cpp index 3849ce47a95..12e7baff4d2 100644 --- a/reference/test/multigrid/amgx_pgm_kernels.cpp +++ b/reference/test/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. *************************************************************/ -#include +#include #include @@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include "core/test/utils.hpp" @@ -61,7 +61,7 @@ namespace { template -class AmgxPgm : public ::testing::Test { +class Pgm : public ::testing::Test { protected: using value_type = typename std::tuple_element<0, decltype(ValueIndexType())>::type; @@ -70,18 +70,18 @@ class AmgxPgm : public ::testing::Test { using Mtx = gko::matrix::Csr; using Vec = gko::matrix::Dense; using SparsityCsr = gko::matrix::SparsityCsr; - using MgLevel = gko::multigrid::AmgxPgm; + using MgLevel = gko::multigrid::Pgm; using RowGatherer = gko::matrix::RowGatherer; using VT = value_type; using real_type = gko::remove_complex; using WeightMtx = gko::matrix::Csr; - AmgxPgm() + Pgm() : exec(gko::ReferenceExecutor::create()), - amgxpgm_factory(MgLevel::build() - .with_max_iterations(2u) - .with_max_unassigned_ratio(0.1) - .with_skip_sorting(true) - .on(exec)), + pgm_factory(MgLevel::build() + .with_max_iterations(2u) + .with_max_unassigned_ratio(0.1) + .with_skip_sorting(true) + .on(exec)), fine_b(gko::initialize( {I({2.0, -1.0}), I({-1.0, 2.0}), I({0.0, -1.0}), I({3.0, -2.0}), I({-2.0, 1.0})}, @@ -112,7 +112,7 @@ class AmgxPgm : public ::testing::Test { agg(exec, 5) { this->create_mtx(mtx.get(), weight.get(), &agg, coarse.get()); - mg_level = amgxpgm_factory->generate(mtx); + mg_level = pgm_factory->generate(mtx); mtx_diag = weight->extract_diagonal(); } @@ -215,19 +215,18 @@ class AmgxPgm : public ::testing::Test { std::shared_ptr prolong_ans; std::shared_ptr prolong_applyans; std::shared_ptr fine_x; - std::unique_ptr amgxpgm_factory; + std::unique_ptr pgm_factory; std::unique_ptr mg_level; }; -TYPED_TEST_SUITE(AmgxPgm, gko::test::ValueIndexTypes, - PairTypenameNameGenerator); +TYPED_TEST_SUITE(Pgm, gko::test::ValueIndexTypes, PairTypenameNameGenerator); -TYPED_TEST(AmgxPgm, CanBeCopied) +TYPED_TEST(Pgm, CanBeCopied) { using Mtx = typename TestFixture::Mtx; using MgLevel = typename TestFixture::MgLevel; - auto copy = this->amgxpgm_factory->generate(Mtx::create(this->exec)); + auto copy = this->pgm_factory->generate(Mtx::create(this->exec)); copy->copy_from(this->mg_level.get()); auto copy_mtx = copy->get_system_matrix(); @@ -243,11 +242,11 @@ TYPED_TEST(AmgxPgm, CanBeCopied) } -TYPED_TEST(AmgxPgm, CanBeMoved) +TYPED_TEST(Pgm, CanBeMoved) { using Mtx = typename TestFixture::Mtx; using MgLevel = typename TestFixture::MgLevel; - auto copy = this->amgxpgm_factory->generate(Mtx::create(this->exec)); + auto copy = this->pgm_factory->generate(Mtx::create(this->exec)); copy->copy_from(std::move(this->mg_level)); auto copy_mtx = copy->get_system_matrix(); @@ -263,7 +262,7 @@ TYPED_TEST(AmgxPgm, CanBeMoved) } -TYPED_TEST(AmgxPgm, CanBeCloned) +TYPED_TEST(Pgm, CanBeCloned) { using Mtx = typename TestFixture::Mtx; using MgLevel = typename TestFixture::MgLevel; @@ -281,7 +280,7 @@ TYPED_TEST(AmgxPgm, CanBeCloned) } -TYPED_TEST(AmgxPgm, CanBeCleared) +TYPED_TEST(Pgm, CanBeCleared) { using MgLevel = typename TestFixture::MgLevel; @@ -296,7 +295,7 @@ TYPED_TEST(AmgxPgm, CanBeCleared) } -TYPED_TEST(AmgxPgm, MatchEdge) +TYPED_TEST(Pgm, MatchEdge) { using index_type = typename TestFixture::index_type; gko::array agg(this->exec, 5); @@ -313,7 +312,7 @@ TYPED_TEST(AmgxPgm, MatchEdge) // isolated item snb_val[4] = 4; - gko::kernels::reference::amgx_pgm::match_edge(this->exec, snb, agg); + gko::kernels::reference::pgm::match_edge(this->exec, snb, agg); ASSERT_EQ(agg_val[0], 0); ASSERT_EQ(agg_val[1], -1); @@ -324,7 +323,7 @@ TYPED_TEST(AmgxPgm, MatchEdge) } -TYPED_TEST(AmgxPgm, CountUnagg) +TYPED_TEST(Pgm, CountUnagg) { using index_type = typename TestFixture::index_type; gko::array agg(this->exec, 5); @@ -336,13 +335,13 @@ TYPED_TEST(AmgxPgm, CountUnagg) agg_val[3] = -1; agg_val[4] = -1; - gko::kernels::reference::amgx_pgm::count_unagg(this->exec, agg, &num_unagg); + gko::kernels::reference::pgm::count_unagg(this->exec, agg, &num_unagg); ASSERT_EQ(num_unagg, 3); } -TYPED_TEST(AmgxPgm, Renumber) +TYPED_TEST(Pgm, Renumber) { using index_type = typename TestFixture::index_type; gko::array agg(this->exec, 5); @@ -354,7 +353,7 @@ TYPED_TEST(AmgxPgm, Renumber) agg_val[3] = 1; agg_val[4] = 4; - gko::kernels::reference::amgx_pgm::renumber(this->exec, agg, &num_agg); + gko::kernels::reference::pgm::renumber(this->exec, agg, &num_agg); ASSERT_EQ(num_agg, 3); ASSERT_EQ(agg_val[0], 0); @@ -365,9 +364,9 @@ TYPED_TEST(AmgxPgm, Renumber) } -TYPED_TEST(AmgxPgm, Generate) +TYPED_TEST(Pgm, Generate) { - auto coarse_fine = this->amgxpgm_factory->generate(this->mtx); + auto coarse_fine = this->pgm_factory->generate(this->mtx); auto agg_result = coarse_fine->get_const_agg(); @@ -379,73 +378,73 @@ TYPED_TEST(AmgxPgm, Generate) } -TYPED_TEST(AmgxPgm, CoarseFineRestrictApply) +TYPED_TEST(Pgm, CoarseFineRestrictApply) { - auto amgx_pgm = this->amgxpgm_factory->generate(this->mtx); + auto pgm = this->pgm_factory->generate(this->mtx); using Vec = typename TestFixture::Vec; using value_type = typename TestFixture::value_type; auto x = Vec::create_with_config_of(gko::lend(this->coarse_b)); - amgx_pgm->get_restrict_op()->apply(this->fine_b.get(), x.get()); + pgm->get_restrict_op()->apply(this->fine_b.get(), x.get()); GKO_ASSERT_MTX_NEAR(x, this->restrict_ans, r::value); } -TYPED_TEST(AmgxPgm, CoarseFineProlongApplyadd) +TYPED_TEST(Pgm, CoarseFineProlongApplyadd) { using value_type = typename TestFixture::value_type; using Vec = typename TestFixture::Vec; - auto amgx_pgm = this->amgxpgm_factory->generate(this->mtx); + auto pgm = this->pgm_factory->generate(this->mtx); auto one = gko::initialize({value_type{1.0}}, this->exec); auto x = gko::clone(this->fine_x); - amgx_pgm->get_prolong_op()->apply(one.get(), this->coarse_b.get(), - one.get(), x.get()); + pgm->get_prolong_op()->apply(one.get(), this->coarse_b.get(), one.get(), + x.get()); GKO_ASSERT_MTX_NEAR(x, this->prolong_ans, r::value); } -TYPED_TEST(AmgxPgm, CoarseFineProlongApply) +TYPED_TEST(Pgm, CoarseFineProlongApply) { using value_type = typename TestFixture::value_type; - auto amgx_pgm = this->amgxpgm_factory->generate(this->mtx); + auto pgm = this->pgm_factory->generate(this->mtx); auto x = gko::clone(this->fine_x); - amgx_pgm->get_prolong_op()->apply(this->coarse_b.get(), x.get()); + pgm->get_prolong_op()->apply(this->coarse_b.get(), x.get()); GKO_ASSERT_MTX_NEAR(x, this->prolong_applyans, r::value); } -TYPED_TEST(AmgxPgm, Apply) +TYPED_TEST(Pgm, Apply) { using VT = typename TestFixture::value_type; using Vec = typename TestFixture::Vec; - auto amgx_pgm = this->amgxpgm_factory->generate(this->mtx); + auto pgm = this->pgm_factory->generate(this->mtx); auto b = gko::clone(this->fine_x); auto x = gko::clone(this->fine_x); - auto exec = amgx_pgm->get_executor(); + auto exec = pgm->get_executor(); auto answer = gko::initialize( {I({-23.0, 5.0}), I({17.0, -5.0}), I({-23.0, 5.0}), I({17.0, -5.0}), I({-23.0, 5.0})}, exec); - amgx_pgm->apply(b.get(), x.get()); + pgm->apply(b.get(), x.get()); GKO_ASSERT_MTX_NEAR(x, answer, r::value); } -TYPED_TEST(AmgxPgm, AdvancedApply) +TYPED_TEST(Pgm, AdvancedApply) { using VT = typename TestFixture::value_type; using Vec = typename TestFixture::Vec; - auto amgx_pgm = this->amgxpgm_factory->generate(this->mtx); + auto pgm = this->pgm_factory->generate(this->mtx); auto b = gko::clone(this->fine_x); auto x = gko::clone(this->fine_x); - auto exec = amgx_pgm->get_executor(); + auto exec = pgm->get_executor(); auto alpha = gko::initialize({1.0}, exec); auto beta = gko::initialize({2.0}, exec); auto answer = gko::initialize( @@ -453,13 +452,13 @@ TYPED_TEST(AmgxPgm, AdvancedApply) I({17.0, -5.0}), I({-23.0, 9.0})}, exec); - amgx_pgm->apply(alpha.get(), b.get(), beta.get(), x.get()); + pgm->apply(alpha.get(), b.get(), beta.get(), x.get()); GKO_ASSERT_MTX_NEAR(x, answer, r::value); } -TYPED_TEST(AmgxPgm, FindStrongestNeighbor) +TYPED_TEST(Pgm, FindStrongestNeighbor) { using index_type = typename TestFixture::index_type; gko::array strongest_neighbor(this->exec, 5); @@ -471,7 +470,7 @@ TYPED_TEST(AmgxPgm, FindStrongestNeighbor) agg_vals[i] = -1; } - gko::kernels::reference::amgx_pgm::find_strongest_neighbor( + gko::kernels::reference::pgm::find_strongest_neighbor( this->exec, this->weight.get(), this->mtx_diag.get(), agg, strongest_neighbor); @@ -483,7 +482,7 @@ TYPED_TEST(AmgxPgm, FindStrongestNeighbor) } -TYPED_TEST(AmgxPgm, AssignToExistAgg) +TYPED_TEST(Pgm, AssignToExistAgg) { using index_type = typename TestFixture::index_type; gko::array agg(this->exec, 5); @@ -496,7 +495,7 @@ TYPED_TEST(AmgxPgm, AssignToExistAgg) agg_vals[3] = 1; agg_vals[4] = -1; - gko::kernels::reference::amgx_pgm::assign_to_exist_agg( + gko::kernels::reference::pgm::assign_to_exist_agg( this->exec, this->weight.get(), this->mtx_diag.get(), agg, intermediate_agg); @@ -508,7 +507,7 @@ TYPED_TEST(AmgxPgm, AssignToExistAgg) } -TYPED_TEST(AmgxPgm, GenerateMgLevel) +TYPED_TEST(Pgm, GenerateMgLevel) { using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; @@ -521,7 +520,7 @@ TYPED_TEST(AmgxPgm, GenerateMgLevel) {{5, 2}, {{0, 0, 1}, {1, 1, 1}, {2, 0, 1}, {3, 1, 1}, {4, 0, 1}}}); auto restrict_op = gko::share(gko::as(prolong_op->transpose())); - auto coarse_fine = this->amgxpgm_factory->generate(this->mtx); + auto coarse_fine = this->pgm_factory->generate(this->mtx); auto row_gatherer = gko::as(coarse_fine->get_prolong_op()); auto row_gather_view = gko::array::const_view( this->exec, row_gatherer->get_size()[0], @@ -537,7 +536,7 @@ TYPED_TEST(AmgxPgm, GenerateMgLevel) } -TYPED_TEST(AmgxPgm, GenerateMgLevelOnUnsortedMatrix) +TYPED_TEST(Pgm, GenerateMgLevelOnUnsortedMatrix) { using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; diff --git a/reference/test/solver/multigrid_kernels.cpp b/reference/test/solver/multigrid_kernels.cpp index 2329339e2c0..f40591e8352 100644 --- a/reference/test/solver/multigrid_kernels.cpp +++ b/reference/test/solver/multigrid_kernels.cpp @@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#include #include #include #include @@ -262,8 +262,8 @@ class Multigrid : public ::testing::Test { using Csr = gko::matrix::Csr; using Mtx = gko::matrix::Dense; using Solver = gko::solver::Multigrid; - using Coarse = gko::multigrid::AmgxPgm; - using CoarseNext = gko::multigrid::AmgxPgm>; + using Coarse = gko::multigrid::Pgm; + using CoarseNext = gko::multigrid::Pgm>; using Smoother = gko::preconditioner::Jacobi; using CoarsestSolver = gko::solver::Cg; using DummyRPFactory = DummyMultigridLevelWithFactory; diff --git a/test/multigrid/CMakeLists.txt b/test/multigrid/CMakeLists.txt index f84b8d83d91..96ecfadb73d 100644 --- a/test/multigrid/CMakeLists.txt +++ b/test/multigrid/CMakeLists.txt @@ -1,2 +1,2 @@ -ginkgo_create_common_test(amgx_pgm_kernels) +ginkgo_create_common_test(pgm_kernels) ginkgo_create_common_test(fixed_coarsening_kernels) diff --git a/test/multigrid/amgx_pgm_kernels.cpp b/test/multigrid/pgm_kernels.cpp similarity index 84% rename from test/multigrid/amgx_pgm_kernels.cpp rename to test/multigrid/pgm_kernels.cpp index 459d862d9dc..9ac5e6ad226 100644 --- a/test/multigrid/amgx_pgm_kernels.cpp +++ b/test/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. *************************************************************/ -#include "core/multigrid/amgx_pgm_kernels.hpp" +#include "core/multigrid/pgm_kernels.hpp" #include @@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#include #include #include #include @@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "test/utils/executor.hpp" -class AmgxPgm : public CommonTestFixture { +class Pgm : public CommonTestFixture { protected: using Mtx = gko::matrix::Dense; using Csr = gko::matrix::Csr; @@ -68,7 +68,7 @@ class AmgxPgm : public CommonTestFixture { using RowGatherer = gko::matrix::RowGatherer; using Diag = gko::matrix::Diagonal; - AmgxPgm() : rand_engine(30) {} + Pgm() : rand_engine(30) {} std::unique_ptr gen_mtx(int num_rows, int num_cols) { @@ -180,43 +180,42 @@ class AmgxPgm : public CommonTestFixture { }; -TEST_F(AmgxPgm, MatchEdgeIsEquivalentToRef) +TEST_F(Pgm, MatchEdgeIsEquivalentToRef) { initialize_data(); auto x = unfinished_agg; auto d_x = d_unfinished_agg; - gko::kernels::reference::amgx_pgm::match_edge(ref, strongest_neighbor, x); - gko::kernels::EXEC_NAMESPACE::amgx_pgm::match_edge( - exec, d_strongest_neighbor, d_x); + gko::kernels::reference::pgm::match_edge(ref, strongest_neighbor, x); + gko::kernels::EXEC_NAMESPACE::pgm::match_edge(exec, d_strongest_neighbor, + d_x); GKO_ASSERT_ARRAY_EQ(d_x, x); } -TEST_F(AmgxPgm, CountUnaggIsEquivalentToRef) +TEST_F(Pgm, CountUnaggIsEquivalentToRef) { initialize_data(); index_type num_unagg; index_type d_num_unagg; - gko::kernels::reference::amgx_pgm::count_unagg(ref, unfinished_agg, - &num_unagg); - gko::kernels::EXEC_NAMESPACE::amgx_pgm::count_unagg(exec, d_unfinished_agg, - &d_num_unagg); + gko::kernels::reference::pgm::count_unagg(ref, unfinished_agg, &num_unagg); + gko::kernels::EXEC_NAMESPACE::pgm::count_unagg(exec, d_unfinished_agg, + &d_num_unagg); ASSERT_EQ(d_num_unagg, num_unagg); } -TEST_F(AmgxPgm, RenumberIsEquivalentToRef) +TEST_F(Pgm, RenumberIsEquivalentToRef) { initialize_data(); index_type num_agg; index_type d_num_agg; - gko::kernels::reference::amgx_pgm::renumber(ref, agg, &num_agg); - gko::kernels::EXEC_NAMESPACE::amgx_pgm::renumber(exec, d_agg, &d_num_agg); + gko::kernels::reference::pgm::renumber(ref, agg, &num_agg); + gko::kernels::EXEC_NAMESPACE::pgm::renumber(exec, d_agg, &d_num_agg); ASSERT_EQ(d_num_agg, num_agg); GKO_ASSERT_ARRAY_EQ(d_agg, agg); @@ -224,22 +223,22 @@ TEST_F(AmgxPgm, RenumberIsEquivalentToRef) } -TEST_F(AmgxPgm, FindStrongestNeighborIsEquivalentToRef) +TEST_F(Pgm, FindStrongestNeighborIsEquivalentToRef) { initialize_data(); auto snb = strongest_neighbor; auto d_snb = d_strongest_neighbor; - gko::kernels::reference::amgx_pgm::find_strongest_neighbor( + gko::kernels::reference::pgm::find_strongest_neighbor( ref, weight_csr.get(), weight_diag.get(), agg, snb); - gko::kernels::EXEC_NAMESPACE::amgx_pgm::find_strongest_neighbor( + gko::kernels::EXEC_NAMESPACE::pgm::find_strongest_neighbor( exec, d_weight_csr.get(), d_weight_diag.get(), d_agg, d_snb); GKO_ASSERT_ARRAY_EQ(d_snb, snb); } -TEST_F(AmgxPgm, AssignToExistAggIsEquivalentToRef) +TEST_F(Pgm, AssignToExistAggIsEquivalentToRef) { initialize_data(); auto x = unfinished_agg; @@ -247,40 +246,39 @@ TEST_F(AmgxPgm, AssignToExistAggIsEquivalentToRef) auto intermediate_agg = x; auto d_intermediate_agg = d_x; - gko::kernels::reference::amgx_pgm::assign_to_exist_agg( + gko::kernels::reference::pgm::assign_to_exist_agg( ref, weight_csr.get(), weight_diag.get(), x, intermediate_agg); - gko::kernels::EXEC_NAMESPACE::amgx_pgm::assign_to_exist_agg( + gko::kernels::EXEC_NAMESPACE::pgm::assign_to_exist_agg( exec, d_weight_csr.get(), d_weight_diag.get(), d_x, d_intermediate_agg); GKO_ASSERT_ARRAY_EQ(d_x, x); } -TEST_F(AmgxPgm, AssignToExistAggUnderteminsticIsEquivalentToRef) +TEST_F(Pgm, AssignToExistAggUnderteminsticIsEquivalentToRef) { initialize_data(); auto d_x = d_unfinished_agg; auto d_intermediate_agg = gko::array(exec, 0); index_type d_num_unagg; - gko::kernels::EXEC_NAMESPACE::amgx_pgm::assign_to_exist_agg( + gko::kernels::EXEC_NAMESPACE::pgm::assign_to_exist_agg( exec, d_weight_csr.get(), d_weight_diag.get(), d_x, d_intermediate_agg); - gko::kernels::EXEC_NAMESPACE::amgx_pgm::count_unagg(exec, d_agg, - &d_num_unagg); + gko::kernels::EXEC_NAMESPACE::pgm::count_unagg(exec, d_agg, &d_num_unagg); // only test whether all elements are aggregated. GKO_ASSERT_EQ(d_num_unagg, 0); } -TEST_F(AmgxPgm, GenerateMgLevelIsEquivalentToRef) +TEST_F(Pgm, GenerateMgLevelIsEquivalentToRef) { initialize_data(); - auto mg_level_factory = gko::multigrid::AmgxPgm::build() + auto mg_level_factory = gko::multigrid::Pgm::build() .with_deterministic(true) .with_skip_sorting(true) .on(ref); - auto d_mg_level_factory = gko::multigrid::AmgxPgm::build() + auto d_mg_level_factory = gko::multigrid::Pgm::build() .with_deterministic(true) .with_skip_sorting(true) .on(exec); @@ -306,15 +304,15 @@ TEST_F(AmgxPgm, GenerateMgLevelIsEquivalentToRef) } -TEST_F(AmgxPgm, GenerateMgLevelIsEquivalentToRefOnUnsortedMatrix) +TEST_F(Pgm, GenerateMgLevelIsEquivalentToRefOnUnsortedMatrix) { initialize_data(); gko::test::unsort_matrix(gko::lend(system_mtx), rand_engine); d_system_mtx = gko::clone(exec, system_mtx); - auto mg_level_factory = gko::multigrid::AmgxPgm::build() + auto mg_level_factory = gko::multigrid::Pgm::build() .with_deterministic(true) .on(ref); - auto d_mg_level_factory = gko::multigrid::AmgxPgm::build() + auto d_mg_level_factory = gko::multigrid::Pgm::build() .with_deterministic(true) .on(exec); diff --git a/test/test_install/test_install.cpp b/test/test_install/test_install.cpp index 67cd0513446..ec042ef18bd 100644 --- a/test/test_install/test_install.cpp +++ b/test/test_install/test_install.cpp @@ -408,9 +408,9 @@ int main() auto test = Mtx::create(exec, gko::dim<2>{2, 2}); } - // core/multigrid/amgx_pgm.hpp + // core/multigrid/pgm.hpp { - auto test = gko::multigrid::AmgxPgm<>::build().on(exec); + auto test = gko::multigrid::Pgm<>::build().on(exec); } // core/preconditioner/ilu.hpp