//@HEADER // ************************************************************************ // // Kokkos v. 4.0 // Copyright (2022) National Technology & Engineering // Solutions of Sandia, LLC (NTESS). // // Under the terms of Contract DE-NA0003525 with NTESS, // the U.S. Government retains certain rights in this software. // // Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions. // See https://kokkos.org/LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //@HEADER #ifndef _KOKKOS_GAUSSSEIDEL_HPP #define _KOKKOS_GAUSSSEIDEL_HPP #include "KokkosSparse_gauss_seidel_spec.hpp" #include "KokkosKernels_Handle.hpp" #include "KokkosKernels_helpers.hpp" #include "KokkosKernels_Error.hpp" namespace KokkosSparse { namespace Experimental { /// /// @brief Gauss-Seidel preconditioner setup (first phase, based on sparsity /// pattern only) /// /// @tparam ExecutionSpace This kernels execution space type. /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @param space The execution space instance this kernel will be run on. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// @pre handle->create_gs_handle(...) has been called previously /// template void gauss_seidel_symbolic(const ExecutionSpace &space, KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, bool is_graph_symmetric = true) { static_assert(std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: Size type of the matrix " "should be same as kernelHandle sizetype."); static_assert(std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: lno type of the matrix " "should be same as kernelHandle lno_t."); typedef typename KernelHandle::const_size_type c_size_t; typedef typename KernelHandle::const_nnz_lno_t c_lno_t; typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; typedef typename KernelHandle::HandleExecSpace c_exec_t; typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; // const_handle_type tmp_handle = *handle; const_handle_type tmp_handle(*handle); typedef Kokkos::View::array_layout, typename lno_row_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_row_view_t_; typedef Kokkos::View::array_layout, typename lno_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_nnz_view_t_; // Internal_alno_row_view_t_ const_a_r = row_map; // Internal_alno_nnz_view_t_ const_a_l = entries; Internal_alno_row_view_t_ const_a_r(row_map.data(), row_map.extent(0)); Internal_alno_nnz_view_t_ const_a_l(entries.data(), entries.extent(0)); using namespace KokkosSparse::Impl; GAUSS_SEIDEL_SYMBOLIC::gauss_seidel_symbolic(space, &tmp_handle, num_rows, num_cols, const_a_r, const_a_l, is_graph_symmetric); } /// /// @brief Gauss-Seidel preconditioner setup (first phase, based on sparsity /// pattern only) /// /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// @pre handle->create_gs_handle(...) has been called previously /// template void gauss_seidel_symbolic(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, bool is_graph_symmetric = true) { auto my_exec_space = handle->get_gs_handle()->get_execution_space(); gauss_seidel_symbolic(my_exec_space, handle, num_rows, num_cols, row_map, entries, is_graph_symmetric); } /// /// @brief Block Gauss-Seidel preconditioner setup (first phase, based on /// sparsity pattern only) /// /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param block_size The number of degrees of freedom per block /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// @pre handle->create_gs_handle(...) has been called previously template void block_gauss_seidel_symbolic(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, typename KernelHandle::const_nnz_lno_t block_size, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, bool is_graph_symmetric = true) { auto gsHandle = handle->get_point_gs_handle(); if (gsHandle->get_algorithm_type() == GS_CLUSTER) { throw std::runtime_error( "Block versions of Gauss-Seidel are incompatible with algorithm " "GS_CLUSTER"); } gsHandle->set_block_size(block_size); gauss_seidel_symbolic(handle, num_rows, num_cols, row_map, entries, is_graph_symmetric); } /// /// @brief Gauss-Seidel preconditioner setup (second phase, based on matrix's /// numeric values) /// /// @tparam ExecutionSpace This kernels execution space type. /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @param space The execution space instance this kernel will be run on. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// template void gauss_seidel_numeric(const ExecutionSpace &space, KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, bool is_graph_symmetric = true) { static_assert(std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: Size type of the matrix " "should be same as kernelHandle sizetype."); static_assert(std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: lno type of the matrix " "should be same as kernelHandle lno_t."); static_assert( std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: scalar type of the matrix should " "be same as kernelHandle scalar_t."); typedef typename KernelHandle::const_size_type c_size_t; typedef typename KernelHandle::const_nnz_lno_t c_lno_t; typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; typedef typename KernelHandle::HandleExecSpace c_exec_t; typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; // const_handle_type tmp_handle = *handle; const_handle_type tmp_handle(*handle); typedef Kokkos::View::array_layout, typename lno_row_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_row_view_t_; typedef Kokkos::View::array_layout, typename lno_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_nnz_view_t_; typedef Kokkos::View::array_layout, typename scalar_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_ascalar_nnz_view_t_; Internal_alno_row_view_t_ const_a_r(row_map.data(), row_map.extent(0)); Internal_alno_nnz_view_t_ const_a_l(entries.data(), entries.extent(0)); Internal_ascalar_nnz_view_t_ const_a_v(values.data(), values.extent(0)); using namespace KokkosSparse::Impl; GAUSS_SEIDEL_NUMERIC::gauss_seidel_numeric(space, &tmp_handle, num_rows, num_cols, const_a_r, const_a_l, const_a_v, is_graph_symmetric); } /// /// @brief Gauss-Seidel preconditioner setup (second phase, based on matrix's /// numeric values). This version accepts the matrix's inverse diagonal from the /// user. /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type. The user-provided /// inverse diagonal must share this type. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// @remark If the inverse diagonal is not already available, it's best to call /// the version of gauss_seidel_numeric that /// doesn't take it as an argument. The inverse diagonal will be /// computed internally. template void gauss_seidel_numeric(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, bool is_graph_symmetric = true) { auto my_exec_space = handle->get_gs_handle()->get_execution_space(); gauss_seidel_numeric(my_exec_space, handle, num_rows, num_cols, row_map, entries, values, is_graph_symmetric); } /// /// @brief Gauss-Seidel preconditioner setup (second phase, based on matrix's /// numeric values). This version accepts the matrix's inverse diagonal from the /// user. /// /// @tparam ExecutionSpace This kernels execution space type. /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type. The user-provided /// inverse diagonal must share this type. /// @param space The execution space instance this kernel will be run on. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param given_inverse_diagonal The inverse (reciprocal) of diagonal /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// @remark If the inverse diagonal is not already available, it's best to call /// the version of gauss_seidel_numeric that /// doesn't take it as an argument. The inverse diagonal will be /// computed internally. template void gauss_seidel_numeric(const ExecutionSpace &space, KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, scalar_nnz_view_t_ given_inverse_diagonal, bool is_graph_symmetric = true) { static_assert(std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: Size type of the matrix " "should be same as kernelHandle sizetype."); static_assert(std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: lno type of the matrix " "should be same as kernelHandle lno_t."); static_assert( std::is_same::value, "KokkosSparse::gauss_seidel_symbolic: scalar type of the matrix should " "be same as kernelHandle scalar_t."); typedef typename KernelHandle::const_size_type c_size_t; typedef typename KernelHandle::const_nnz_lno_t c_lno_t; typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; typedef typename KernelHandle::HandleExecSpace c_exec_t; typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; // const_handle_type tmp_handle = *handle; const_handle_type tmp_handle(*handle); typedef Kokkos::View::array_layout, typename lno_row_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_row_view_t_; typedef Kokkos::View::array_layout, typename lno_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_nnz_view_t_; typedef Kokkos::View::array_layout, typename scalar_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_ascalar_nnz_view_t_; Internal_alno_row_view_t_ const_a_r(row_map.data(), row_map.extent(0)); Internal_alno_nnz_view_t_ const_a_l(entries.data(), entries.extent(0)); Internal_ascalar_nnz_view_t_ const_a_v(values.data(), values.extent(0)); Internal_ascalar_nnz_view_t_ const_a_d(given_inverse_diagonal.data(), given_inverse_diagonal.extent(0)); using namespace KokkosSparse::Impl; GAUSS_SEIDEL_NUMERIC::gauss_seidel_numeric(space, &tmp_handle, num_rows, num_cols, const_a_r, const_a_l, const_a_v, const_a_d, is_graph_symmetric); } /// /// @brief Gauss-Seidel preconditioner setup (second phase, based on matrix's /// numeric values). This version accepts the matrix's inverse diagonal from the /// user. /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type. The user-provided /// inverse diagonal must share this type. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param given_inverse_diagonal The inverse (reciprocal) of diagonal /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// @remark If the inverse diagonal is not already available, it's best to call /// the version of gauss_seidel_numeric that /// doesn't take it as an argument. The inverse diagonal will be /// computed internally. template void gauss_seidel_numeric(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, scalar_nnz_view_t_ given_inverse_diagonal, bool is_graph_symmetric = true) { auto my_exec_space = handle->get_gs_handle()->get_execution_space(); gauss_seidel_numeric(my_exec_space, handle, num_rows, num_cols, row_map, entries, values, given_inverse_diagonal, is_graph_symmetric); } /// /// @brief Block Gauss-Seidel preconditioner setup (second phase, based on /// matrix's numeric values) /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @param handle handle A KokkosKernelsHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param block_size The number of degrees of freedom per block /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param is_graph_symmetric Whether the upper-left num_rows x /// num_rows submatrix of A is structurally symmetric /// template void block_gauss_seidel_numeric(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, typename KernelHandle::const_nnz_lno_t block_size, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, bool is_graph_symmetric = true) { auto gsHandle = handle->get_point_gs_handle(); if (gsHandle->get_algorithm_type() == GS_CLUSTER) { throw std::runtime_error( "Block versions of Gauss-Seidel are incompatible with algorithm " "GS_CLUSTER"); } gsHandle->set_block_size(block_size); gauss_seidel_numeric(handle, num_rows, num_cols, row_map, entries, values, is_graph_symmetric); } /// /// @brief Apply symmetric (forward + backward) Gauss-Seidel preconditioner to /// system AX=Y /// /// @tparam ExecutionSpace This kernels execution space type. /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param space The execution space instance this kernel will be run /// on. NOTE: Currently only used for GS_DEFAULT. /// @param handle handle A KokkosKernelsHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run (forward and backward counts as 1) /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void symmetric_gauss_seidel_apply(const ExecutionSpace &space, KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { static_assert(std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: Size type of the " "matrix should be same as kernelHandle sizetype."); static_assert(std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: lno type of the " "matrix should be same as kernelHandle lno_t."); static_assert( std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: scalar type of the matrix " "should be same as kernelHandle scalar_t."); static_assert( std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: scalar type of " "the y-vector should be same as kernelHandle scalar_t."); static_assert(std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: scalar type of the x-vector " "should be same as kernelHandle non-const scalar_t."); static_assert(!std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: row_map must have " "a contiguous layout (Left or Right, not Stride)"); static_assert(!std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: entries must have " "a contiguous layout (Left or Right, not Stride)"); static_assert(!std::is_same::value, "KokkosSparse::symmetric_gauss_seidel_apply: values must have " "a contiguous layout (Left or Right, not Stride)"); // Check compatibility of #vectors if (x_lhs_output_vec.extent(1) != y_rhs_input_vec.extent(1)) { std::ostringstream os; os << "KokkosSparse::symmetric_gauss_seidel_apply: " << "X has " << x_lhs_output_vec.extent(1) << "columns, Y has " << y_rhs_input_vec.extent(1) << " columns."; KokkosKernels::Impl::throw_runtime_exception(os.str()); } typedef typename KernelHandle::const_size_type c_size_t; typedef typename KernelHandle::const_nnz_lno_t c_lno_t; typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; typedef typename KernelHandle::HandleExecSpace c_exec_t; typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; const_handle_type tmp_handle(*handle); typedef Kokkos::View::array_layout, typename lno_row_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_row_view_t_; typedef Kokkos::View::array_layout, typename lno_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_nnz_view_t_; typedef Kokkos::View::array_layout, typename scalar_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_ascalar_nnz_view_t_; typedef Kokkos::View::array_layout, typename y_scalar_view_t::device_type, Kokkos::MemoryTraits > Internal_yscalar_nnz_view_t_; typedef Kokkos::View::array_layout, typename x_scalar_view_t::device_type, Kokkos::MemoryTraits > Internal_xscalar_nnz_view_t_; Internal_alno_row_view_t_ const_a_r(row_map.data(), row_map.extent(0)); Internal_alno_nnz_view_t_ const_a_l(entries.data(), entries.extent(0)); Internal_ascalar_nnz_view_t_ const_a_v(values.data(), values.extent(0)); Internal_xscalar_nnz_view_t_ nonconst_x_v(x_lhs_output_vec.data(), x_lhs_output_vec.extent(0), x_lhs_output_vec.extent(1)); Internal_yscalar_nnz_view_t_ const_y_v(y_rhs_input_vec.data(), y_rhs_input_vec.extent(0), y_rhs_input_vec.extent(1)); using namespace KokkosSparse::Impl; GAUSS_SEIDEL_APPLY::gauss_seidel_apply(space, &tmp_handle, num_rows, num_cols, const_a_r, const_a_l, const_a_v, nonconst_x_v, const_y_v, init_zero_x_vector, update_y_vector, omega, numIter, true, true); } /// /// @brief Apply symmetric (forward + backward) Gauss-Seidel preconditioner to /// system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param handle handle A KokkosKernelsHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run (forward and backward counts as 1) /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void symmetric_gauss_seidel_apply(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { auto my_exec_space = handle->get_gs_handle()->get_execution_space(); symmetric_gauss_seidel_apply(my_exec_space, handle, num_rows, num_cols, row_map, entries, values, x_lhs_output_vec, y_rhs_input_vec, init_zero_x_vector, update_y_vector, omega, numIter); } /// /// @brief Apply symmetric (forward + backward) Block Gauss-Seidel /// preconditioner to system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param handle handle A KokkosKernelsHandle instance. /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param block_size The number of degrees of freedom per block /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run (forward and backward counts as 1) /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void symmetric_block_gauss_seidel_apply(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, typename KernelHandle::const_nnz_lno_t block_size, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { // Check compatibility of dimensions at run time. if (x_lhs_output_vec.extent(1) != y_rhs_input_vec.extent(1)) { std::ostringstream os; os << "KokkosSparse::symmetric_block_gauss_seidel_apply: Dimensions of X " "and Y do not match: " << "X has " << x_lhs_output_vec.extent(1) << "columns, Y has " << y_rhs_input_vec.extent(1) << " columns."; KokkosKernels::Impl::throw_runtime_exception(os.str()); } auto gsHandle = handle->get_point_gs_handle(); if (gsHandle->get_algorithm_type() == GS_CLUSTER) { throw std::runtime_error( "Block versions of Gauss-Seidel are incompatible with algorithm " "GS_CLUSTER"); } gsHandle->set_block_size(block_size); symmetric_gauss_seidel_apply(handle, num_rows, num_cols, row_map, entries, values, x_lhs_output_vec, y_rhs_input_vec, init_zero_x_vector, update_y_vector, omega, numIter); } /// /// @brief Apply forward Gauss-Seidel preconditioner to system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param space The execution space instance this kernel will be run /// on. NOTE: Currently only used for GS_DEFAULT. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void forward_sweep_gauss_seidel_apply(const ExecutionSpace &space, KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { static_assert(std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: Size type of " "the matrix should be same as kernelHandle sizetype."); static_assert(std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: lno type of " "the matrix should be same as kernelHandle lno_t."); static_assert( std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: scalar type of the " "matrix should be same as kernelHandle scalar_t."); static_assert( std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: scalar type " "of the y-vector should be same as kernelHandle scalar_t."); static_assert(std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: scalar type of the " "x-vector should be same as kernelHandle non-const scalar_t."); static_assert(!std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: row_map must " "have a contiguous layout (Left or Right, not Stride)"); static_assert(!std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: entries must " "have a contiguous layout (Left or Right, not Stride)"); static_assert(!std::is_same::value, "KokkosSparse::forward_sweep_gauss_seidel_apply: values must " "have a contiguous layout (Left or Right, not Stride)"); // Check compatibility of dimensions at run time. if (x_lhs_output_vec.extent(1) != y_rhs_input_vec.extent(1)) { std::ostringstream os; os << "KokkosSparse::forward_sweep_gauss_seidel_apply: Dimensions of X and " "Y do not match: " << "X has " << x_lhs_output_vec.extent(1) << "columns, Y has " << y_rhs_input_vec.extent(1) << " columns."; KokkosKernels::Impl::throw_runtime_exception(os.str()); } typedef typename KernelHandle::const_size_type c_size_t; typedef typename KernelHandle::const_nnz_lno_t c_lno_t; typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; typedef typename KernelHandle::HandleExecSpace c_exec_t; typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; // const_handle_type tmp_handle = *handle; const_handle_type tmp_handle(*handle); typedef Kokkos::View::array_layout, typename lno_row_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_row_view_t_; typedef Kokkos::View::array_layout, typename lno_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_nnz_view_t_; typedef Kokkos::View::array_layout, typename scalar_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_ascalar_nnz_view_t_; typedef Kokkos::View::array_layout, typename y_scalar_view_t::device_type, Kokkos::MemoryTraits > Internal_yscalar_nnz_view_t_; typedef Kokkos::View::array_layout, typename x_scalar_view_t::device_type, Kokkos::MemoryTraits > Internal_xscalar_nnz_view_t_; Internal_alno_row_view_t_ const_a_r(row_map.data(), row_map.extent(0)); Internal_alno_nnz_view_t_ const_a_l(entries.data(), entries.extent(0)); Internal_ascalar_nnz_view_t_ const_a_v(values.data(), values.extent(0)); Internal_xscalar_nnz_view_t_ nonconst_x_v(x_lhs_output_vec.data(), x_lhs_output_vec.extent(0), x_lhs_output_vec.extent(1)); Internal_yscalar_nnz_view_t_ const_y_v(y_rhs_input_vec.data(), y_rhs_input_vec.extent(0), y_rhs_input_vec.extent(1)); using namespace KokkosSparse::Impl; GAUSS_SEIDEL_APPLY::gauss_seidel_apply(space, &tmp_handle, num_rows, num_cols, const_a_r, const_a_l, const_a_v, nonconst_x_v, const_y_v, init_zero_x_vector, update_y_vector, omega, numIter, true, false); } /// /// @brief Apply forward Gauss-Seidel preconditioner to system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void forward_sweep_gauss_seidel_apply(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { auto my_exec_space = handle->get_gs_handle()->get_execution_space(); forward_sweep_gauss_seidel_apply( my_exec_space, handle, num_rows, num_cols, row_map, entries, values, x_lhs_output_vec, y_rhs_input_vec, init_zero_x_vector, update_y_vector, omega, numIter); } /// /// @brief Apply forward Block Gauss-Seidel preconditioner to system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param block_size The number of degrees of freedom per block /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void forward_sweep_block_gauss_seidel_apply(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, typename KernelHandle::const_nnz_lno_t block_size, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { // Check compatibility of dimensions at run time. if (x_lhs_output_vec.extent(1) != y_rhs_input_vec.extent(1)) { std::ostringstream os; os << "KokkosSparse::forward_sweep_block_gauss_seidel_apply: Dimensions of " "X and Y do not match: " << "X has " << x_lhs_output_vec.extent(1) << "columns, Y has " << y_rhs_input_vec.extent(1) << " columns."; KokkosKernels::Impl::throw_runtime_exception(os.str()); } auto gsHandle = handle->get_point_gs_handle(); if (gsHandle->get_algorithm_type() == GS_CLUSTER) { throw std::runtime_error( "Block versions of Gauss-Seidel are incompatible with algorithm " "GS_CLUSTER"); } gsHandle->set_block_size(block_size); forward_sweep_gauss_seidel_apply(handle, num_rows, num_cols, row_map, entries, values, x_lhs_output_vec, y_rhs_input_vec, init_zero_x_vector, update_y_vector, omega, numIter); } /// /// @brief Apply backward Gauss-Seidel preconditioner to system AX=Y /// /// @tparam ExecutionSpace This kernels execution space type. /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param space The execution space instance this kernel will be run /// on. NOTE: Currently only used for GS_DEFAULT. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void backward_sweep_gauss_seidel_apply(const ExecutionSpace &space, KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { static_assert(std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: Size type of " "the matrix should be same as kernelHandle sizetype."); static_assert(std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: lno type of " "the matrix should be same as kernelHandle lno_t."); static_assert( std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: scalar type of the " "matrix should be same as kernelHandle scalar_t."); static_assert( std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: scalar type " "of the y-vector should be same as kernelHandle scalar_t."); static_assert(std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: scalar type of the " "x-vector should be same as kernelHandle non-const scalar_t."); static_assert(!std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: row_map must " "have a contiguous layout (Left or Right, not Stride)"); static_assert(!std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: entries must " "have a contiguous layout (Left or Right, not Stride)"); static_assert(!std::is_same::value, "KokkosSparse::backward_sweep_gauss_seidel_apply: values must " "have a contiguous layout (Left or Right, not Stride)"); // Check compatibility of dimensions at run time. if (x_lhs_output_vec.extent(1) != y_rhs_input_vec.extent(1)) { std::ostringstream os; os << "KokkosSparse::backward_sweep_gauss_seidel_apply: Dimensions of X " "and Y do not match: " << "X has " << x_lhs_output_vec.extent(1) << "columns, Y has " << y_rhs_input_vec.extent(1) << " columns."; KokkosKernels::Impl::throw_runtime_exception(os.str()); } typedef typename KernelHandle::const_size_type c_size_t; typedef typename KernelHandle::const_nnz_lno_t c_lno_t; typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; typedef typename KernelHandle::HandleExecSpace c_exec_t; typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; // const_handle_type tmp_handle = *handle; const_handle_type tmp_handle(*handle); typedef Kokkos::View::array_layout, typename lno_row_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_row_view_t_; typedef Kokkos::View::array_layout, typename lno_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_alno_nnz_view_t_; typedef Kokkos::View::array_layout, typename scalar_nnz_view_t_::device_type, Kokkos::MemoryTraits > Internal_ascalar_nnz_view_t_; typedef Kokkos::View::array_layout, typename y_scalar_view_t::device_type, Kokkos::MemoryTraits > Internal_yscalar_nnz_view_t_; typedef Kokkos::View::array_layout, typename x_scalar_view_t::device_type, Kokkos::MemoryTraits > Internal_xscalar_nnz_view_t_; Internal_alno_row_view_t_ const_a_r(row_map.data(), row_map.extent(0)); Internal_alno_nnz_view_t_ const_a_l(entries.data(), entries.extent(0)); Internal_ascalar_nnz_view_t_ const_a_v(values.data(), values.extent(0)); Internal_xscalar_nnz_view_t_ nonconst_x_v(x_lhs_output_vec.data(), x_lhs_output_vec.extent(0), x_lhs_output_vec.extent(1)); Internal_yscalar_nnz_view_t_ const_y_v(y_rhs_input_vec.data(), y_rhs_input_vec.extent(0), y_rhs_input_vec.extent(1)); using namespace KokkosSparse::Impl; GAUSS_SEIDEL_APPLY::gauss_seidel_apply(space, &tmp_handle, num_rows, num_cols, const_a_r, const_a_l, const_a_v, nonconst_x_v, const_y_v, init_zero_x_vector, update_y_vector, omega, numIter, false, true); } /// /// @brief Apply backward Gauss-Seidel preconditioner to system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void backward_sweep_gauss_seidel_apply(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { auto my_exec_space = handle->get_gs_handle()->get_execution_space(); backward_sweep_gauss_seidel_apply( my_exec_space, handle, num_rows, num_cols, row_map, entries, values, x_lhs_output_vec, y_rhs_input_vec, init_zero_x_vector, update_y_vector, omega, numIter); } /// /// @brief Apply backward Block Gauss-Seidel preconditioner to system AX=Y /// /// @tparam format The matrix storage format, CRS or BSR /// @tparam KernelHandle A specialization of /// KokkosKernels::Experimental::KokkosKernelsHandle /// @tparam lno_row_view_t_ The matrix's rowmap type /// @tparam lno_nnz_view_t_ The matrix's entries type /// @tparam scalar_nnz_view_t_ The matrix's values type /// @tparam x_scalar_view_t The type of the X (left-hand side, unknown) vector. /// May be rank-1 or rank-2 View. /// @tparam y_scalar_view_t The type of the Y (right-hand side) vector. May be /// rank-1 or rank-2 View. /// @param handle KernelHandle instance /// @param num_rows Number of rows in the matrix /// @param num_cols Number of columns in the matrix /// @param block_size The number of degrees of freedom per block /// @param row_map The matrix's rowmap /// @param entries The matrix's entries /// @param values The matrix's values /// @param x_lhs_output_vec The X (left-hand side, unknown) vector /// @param y_rhs_input_vec The Y (right-hand side) vector /// @param init_zero_x_vector Whether to zero out X before applying /// @param update_y_vector Whether Y has changed since the last call to apply /// @param omega The damping factor for successive over-relaxation /// @param numIter How many iterations to run /// @pre x_lhs_output_vec.extent(0) == num_cols /// @pre y_rhs_input_vec.extent(0) == num_rows /// @pre x_lhs_output_vec.extent(1) == y_rhs_input_vec.extent(1) /// template void backward_sweep_block_gauss_seidel_apply(KernelHandle *handle, typename KernelHandle::const_nnz_lno_t num_rows, typename KernelHandle::const_nnz_lno_t num_cols, typename KernelHandle::const_nnz_lno_t block_size, lno_row_view_t_ row_map, lno_nnz_view_t_ entries, scalar_nnz_view_t_ values, x_scalar_view_t x_lhs_output_vec, y_scalar_view_t y_rhs_input_vec, bool init_zero_x_vector, bool update_y_vector, typename KernelHandle::nnz_scalar_t omega, int numIter) { // Check compatibility of dimensions at run time. if (x_lhs_output_vec.extent(1) != y_rhs_input_vec.extent(1)) { std::ostringstream os; os << "KokkosSparse::backward_sweep_block_gauss_seidel_apply: Dimensions " "of X and Y do not match: " << "X has " << x_lhs_output_vec.extent(1) << "columns, Y has " << y_rhs_input_vec.extent(1) << " columns."; KokkosKernels::Impl::throw_runtime_exception(os.str()); } auto gsHandle = handle->get_point_gs_handle(); if (gsHandle->get_algorithm_type() == GS_CLUSTER) { throw std::runtime_error( "Block versions of Gauss-Seidel are incompatible with algorithm " "GS_CLUSTER"); } gsHandle->set_block_size(block_size); backward_sweep_gauss_seidel_apply(handle, num_rows, num_cols, row_map, entries, values, x_lhs_output_vec, y_rhs_input_vec, init_zero_x_vector, update_y_vector, omega, numIter); } } // namespace Experimental } // namespace KokkosSparse #endif