5#ifndef GKO_PUBLIC_CORE_SOLVER_BATCH_SOLVER_BASE_HPP_
6#define GKO_PUBLIC_CORE_SOLVER_BATCH_SOLVER_BASE_HPP_
9#include <ginkgo/core/base/abstract_factory.hpp>
10#include <ginkgo/core/base/batch_lin_op.hpp>
11#include <ginkgo/core/base/batch_multi_vector.hpp>
12#include <ginkgo/core/base/utils_helper.hpp>
13#include <ginkgo/core/log/batch_logger.hpp>
14#include <ginkgo/core/matrix/batch_identity.hpp>
15#include <ginkgo/core/stop/batch_stop_enum.hpp>
38 return this->system_matrix_;
48 return this->preconditioner_;
67 GKO_INVALID_STATE(
"Tolerance cannot be negative!");
69 this->residual_tol_ = res_tol;
87 if (max_iterations < 0) {
88 GKO_INVALID_STATE(
"Max iterations cannot be negative!");
90 this->max_iterations_ = max_iterations;
100 return this->tol_type_;
110 if (tol_type == ::gko::batch::stop::tolerance_type::absolute ||
111 tol_type == ::gko::batch::stop::tolerance_type::relative) {
112 this->tol_type_ = tol_type;
114 GKO_INVALID_STATE(
"Invalid tolerance type specified!");
121 BatchSolver(std::shared_ptr<const BatchLinOp> system_matrix,
122 std::shared_ptr<const BatchLinOp> gen_preconditioner,
123 const double res_tol,
const int max_iterations,
124 const ::gko::batch::stop::tolerance_type tol_type)
125 : system_matrix_{
std::move(system_matrix)},
126 preconditioner_{
std::move(gen_preconditioner)},
127 residual_tol_{res_tol},
128 max_iterations_{max_iterations},
133 void set_system_matrix_base(std::shared_ptr<const BatchLinOp> system_matrix)
135 this->system_matrix_ = std::move(system_matrix);
138 void set_preconditioner_base(std::shared_ptr<const BatchLinOp> precond)
140 this->preconditioner_ = std::move(precond);
143 std::shared_ptr<const BatchLinOp> system_matrix_{};
144 std::shared_ptr<const BatchLinOp> preconditioner_{};
145 double residual_tol_{};
146 int max_iterations_{};
147 ::gko::batch::stop::tolerance_type tol_type_{};
148 mutable array<unsigned char> workspace_{};
152template <
typename Parameters,
typename Factory>
182 std::shared_ptr<const BatchLinOpFactory> GKO_DEFERRED_FACTORY_PARAMETER(
202template <
typename ConcreteSolver,
typename ValueType,
204class EnableBatchSolver
205 :
public BatchSolver,
213 this->validate_application_parameters(b.get(), x.get());
214 auto exec = this->get_executor();
225 this->validate_application_parameters(alpha.get(), b.get(), beta.get(),
227 auto exec = this->get_executor();
238 this->validate_application_parameters(b.get(), x.get());
239 auto exec = this->get_executor();
250 this->validate_application_parameters(alpha.get(), b.get(), beta.get(),
252 auto exec = this->get_executor();
261 GKO_ENABLE_SELF(ConcreteSolver);
263 explicit EnableBatchSolver(std::shared_ptr<const Executor> exec)
267 template <
typename FactoryParameters>
268 explicit EnableBatchSolver(std::shared_ptr<const Executor> exec,
269 std::shared_ptr<const BatchLinOp> system_matrix,
270 const FactoryParameters& params)
271 : BatchSolver(system_matrix,
nullptr, params.tolerance,
272 params.max_iterations, params.tolerance_type),
276 GKO_ASSERT_BATCH_HAS_SQUARE_DIMENSIONS(system_matrix_);
278 using value_type =
typename ConcreteSolver::value_type;
282 if (params.generated_preconditioner) {
283 GKO_ASSERT_BATCH_EQUAL_DIMENSIONS(params.generated_preconditioner,
285 preconditioner_ = std::move(params.generated_preconditioner);
286 }
else if (params.preconditioner) {
287 preconditioner_ = params.preconditioner->generate(system_matrix_);
289 auto id = Identity::create(exec, system_matrix->get_size());
290 preconditioner_ = std::move(
id);
296 system_matrix->get_num_batch_items() * 32;
297 workspace_.set_executor(exec);
298 workspace_.resize_and_reset(workspace_size);
301 void set_system_matrix(std::shared_ptr<const BatchLinOp> new_system_matrix)
303 auto exec = self()->get_executor();
304 if (new_system_matrix) {
305 GKO_ASSERT_BATCH_EQUAL_DIMENSIONS(self(), new_system_matrix);
306 GKO_ASSERT_BATCH_HAS_SQUARE_DIMENSIONS(new_system_matrix);
307 if (new_system_matrix->get_executor() != exec) {
308 new_system_matrix =
gko::clone(exec, new_system_matrix);
311 this->set_system_matrix_base(new_system_matrix);
314 void set_preconditioner(std::shared_ptr<const BatchLinOp> new_precond)
316 auto exec = self()->get_executor();
318 GKO_ASSERT_BATCH_EQUAL_DIMENSIONS(self(), new_precond);
319 GKO_ASSERT_BATCH_HAS_SQUARE_DIMENSIONS(new_precond);
320 if (new_precond->get_executor() != exec) {
324 this->set_preconditioner_base(new_precond);
327 EnableBatchSolver& operator=(
const EnableBatchSolver& other)
329 if (&other !=
this) {
330 this->set_size(other.get_size());
341 EnableBatchSolver& operator=(EnableBatchSolver&& other)
343 if (&other !=
this) {
344 this->set_size(other.get_size());
350 other.set_system_matrix(
nullptr);
351 other.set_preconditioner(
nullptr);
356 EnableBatchSolver(
const EnableBatchSolver& other)
358 other.self()->get_executor(), other.self()->get_size())
363 EnableBatchSolver(EnableBatchSolver&& other)
365 other.self()->get_executor(), other.self()->get_size())
367 *
this = std::move(other);
373 auto exec = this->get_executor();
377 auto workspace_view = workspace_.as_view();
378 auto log_data_ = std::make_unique<log::detail::log_data<real_type>>(
381 this->solver_apply(b, x, log_data_.get());
384 log_data_->iter_counts, log_data_->res_norms);
392 auto x_clone = x->clone();
393 this->apply(b, x_clone.get());
400 log::detail::log_data<real_type>* info)
const = 0;
Definition batch_lin_op.hpp:59
The EnableBatchLinOp mixin can be used to provide sensible default implementations of the majority of...
Definition batch_lin_op.hpp:252
MultiVector stores multiple vectors in a batched fashion and is useful for batched operations.
Definition batch_multi_vector.hpp:59
void scale(ptr_param< const MultiVector< ValueType > > alpha)
Scales the vector with a scalar (aka: BLAS scal).
dim< 2 > get_common_size() const
Returns the common size of the batch items.
Definition batch_multi_vector.hpp:144
size_type get_num_batch_items() const
Returns the number of batch items.
Definition batch_multi_vector.hpp:134
void add_scaled(ptr_param< const MultiVector< ValueType > > alpha, ptr_param< const MultiVector< ValueType > > b)
Adds b scaled by alpha to the vector (aka: BLAS axpy).
The batch Identity matrix, which represents a batch of Identity matrices.
Definition batch_identity.hpp:32
The BatchSolver is a base class for all batched solvers and provides the common getters and setter fo...
Definition batch_solver_base.hpp:29
std::shared_ptr< const BatchLinOp > get_system_matrix() const
Returns the system operator (matrix) of the linear system.
Definition batch_solver_base.hpp:36
void reset_max_iterations(int max_iterations)
Set the maximum number of iterations for the solver to use, independent of the factory that created i...
Definition batch_solver_base.hpp:85
double get_tolerance() const
Get the residual tolerance used by the solver.
Definition batch_solver_base.hpp:56
int get_max_iterations() const
Get the maximum number of iterations set on the solver.
Definition batch_solver_base.hpp:77
void reset_tolerance(double res_tol)
Update the residual tolerance to be used by the solver.
Definition batch_solver_base.hpp:64
::gko::batch::stop::tolerance_type get_tolerance_type() const
Get the tolerance type.
Definition batch_solver_base.hpp:98
void reset_tolerance_type(::gko::batch::stop::tolerance_type tol_type)
Set the type of tolerance check to use inside the solver.
Definition batch_solver_base.hpp:108
std::shared_ptr< const BatchLinOp > get_preconditioner() const
Returns the generated preconditioner.
Definition batch_solver_base.hpp:46
The enable_parameters_type mixin is used to create a base implementation of the factory parameters st...
Definition abstract_factory.hpp:211
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:41
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)
Creates a scalar factory parameter in the factory parameters structure.
Definition abstract_factory.hpp:445
The logger namespace .
Definition batch_logger.hpp:23
The Ginkgo namespace.
Definition abstract_factory.hpp:20
typename detail::remove_complex_s< T >::type remove_complex
Obtain the type which removed the complex of complex/scalar type or the template parameter of class b...
Definition math.hpp:260
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:89
detail::cloned_type< Pointer > clone(const Pointer &p)
Creates a unique clone of the object pointed to by p.
Definition utils_helper.hpp:173
batch_dim< 2, DimensionType > transpose(const batch_dim< 2, DimensionType > &input)
Returns a batch_dim object with its dimensions swapped for batched operators.
Definition batch_dim.hpp:119
detail::temporary_clone< detail::pointee< Ptr > > make_temporary_clone(std::shared_ptr< const Executor > exec, Ptr &&ptr)
Creates a temporary_clone.
Definition temporary_clone.hpp:208
Definition batch_solver_base.hpp:154
int max_iterations
Default maximum number iterations allowed.
Definition batch_solver_base.hpp:161
double tolerance
Default residual tolerance.
Definition batch_solver_base.hpp:169
std::shared_ptr< const BatchLinOpFactory > preconditioner
The preconditioner to be used by the iterative solver.
Definition batch_solver_base.hpp:183
::gko::batch::stop::tolerance_type tolerance_type
To specify which type of tolerance check is to be considered, absolute or relative (to the rhs l2 nor...
Definition batch_solver_base.hpp:176
std::shared_ptr< const BatchLinOp > generated_preconditioner
Already generated preconditioner.
Definition batch_solver_base.hpp:190