Ginkgo Generated from branch based on main. Ginkgo version 1.9.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
scaled_reordered.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_REORDER_SCALED_REORDERED_HPP_
6#define GKO_PUBLIC_CORE_REORDER_SCALED_REORDERED_HPP_
7
8
9#include <ginkgo/core/base/abstract_factory.hpp>
10#include <ginkgo/core/base/executor.hpp>
11#include <ginkgo/core/base/lin_op.hpp>
12#include <ginkgo/core/base/types.hpp>
13#include <ginkgo/core/matrix/dense.hpp>
14#include <ginkgo/core/matrix/diagonal.hpp>
15#include <ginkgo/core/matrix/identity.hpp>
16#include <ginkgo/core/matrix/permutation.hpp>
17#include <ginkgo/core/reorder/reordering_base.hpp>
18
19
20namespace gko {
21namespace experimental {
22namespace reorder {
23
24
43template <typename ValueType = default_precision, typename IndexType = int32>
45 : public EnableLinOp<ScaledReordered<ValueType, IndexType>> {
46 friend class EnableLinOp<ScaledReordered, LinOp>;
48
49public:
50 using value_type = ValueType;
51 using index_type = IndexType;
55
56 std::shared_ptr<const LinOp> get_system_matrix() const
57 {
58 return system_matrix_;
59 }
60
61 std::shared_ptr<const LinOp> get_inner_operator() const
62 {
63 return inner_operator_;
64 }
65
67 {
72 std::shared_ptr<const LinOpFactory> GKO_FACTORY_PARAMETER_SCALAR(
73 inner_operator, nullptr);
74
80 std::shared_ptr<const ReorderingBaseFactory>
81 GKO_FACTORY_PARAMETER_SCALAR(reordering, nullptr);
82
86 std::shared_ptr<const matrix::Diagonal<value_type>>
87 GKO_FACTORY_PARAMETER_SCALAR(row_scaling, nullptr);
88
92 std::shared_ptr<const matrix::Diagonal<value_type>>
93 GKO_FACTORY_PARAMETER_SCALAR(col_scaling, nullptr);
94 };
97
98protected:
102 explicit ScaledReordered(std::shared_ptr<const Executor> exec)
103 : EnableLinOp<ScaledReordered>(std::move(exec)),
104 permutation_array_{exec}
105 {}
106
107 explicit ScaledReordered(const Factory* factory,
108 std::shared_ptr<const LinOp> system_matrix)
110 system_matrix->get_size()),
111 parameters_{factory->get_parameters()},
112 permutation_array_{factory->get_executor()}
113 {
114 // For now only support square matrices.
115 GKO_ASSERT_IS_SQUARE_MATRIX(system_matrix);
116
117 auto exec = this->get_executor();
118
119 system_matrix_ = gko::clone(exec, system_matrix);
120
121 // Scale the system matrix if scaling coefficients are provided
122 if (parameters_.row_scaling) {
123 GKO_ASSERT_EQUAL_DIMENSIONS(parameters_.row_scaling,
124 system_matrix_);
125 row_scaling_ = parameters_.row_scaling;
126 row_scaling_->apply(system_matrix_, system_matrix_);
127 }
128 if (parameters_.col_scaling) {
129 GKO_ASSERT_EQUAL_DIMENSIONS(parameters_.col_scaling,
130 system_matrix_);
131 col_scaling_ = parameters_.col_scaling;
132 col_scaling_->rapply(system_matrix_, system_matrix_);
133 }
134
135 // If a reordering factory is provided, generate the reordering and
136 // permute the system matrix accordingly.
137 if (parameters_.reordering) {
138 auto reordering = parameters_.reordering->generate(system_matrix_);
139 permutation_array_ = reordering->get_permutation_array();
140 system_matrix_ = as<Permutable<index_type>>(system_matrix_)
141 ->permute(&permutation_array_);
142 }
143
144 // Generate the inner operator with the scaled and reordered system
145 // matrix. If none is provided, use the Identity.
146 if (parameters_.inner_operator) {
147 inner_operator_ =
148 parameters_.inner_operator->generate(system_matrix_);
149 } else {
151 exec, this->get_size()[0]);
152 }
153 }
154
155 void apply_impl(const LinOp* b, LinOp* x) const override;
156
157 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
158 LinOp* x) const override;
159
171 void set_cache_to(const LinOp* b, const LinOp* x) const
172 {
173 if (cache_.inner_b == nullptr ||
174 cache_.inner_b->get_size() != b->get_size()) {
175 const auto size = b->get_size();
176 cache_.inner_b =
178 cache_.inner_x =
180 cache_.intermediate =
182 }
183 cache_.inner_b->copy_from(b);
184 if (inner_operator_->apply_uses_initial_guess()) {
185 cache_.inner_x->copy_from(x);
186 }
187 }
188
189private:
190 std::shared_ptr<LinOp> system_matrix_{};
191 std::shared_ptr<const LinOp> inner_operator_{};
192 std::shared_ptr<const matrix::Diagonal<value_type>> row_scaling_{};
193 std::shared_ptr<const matrix::Diagonal<value_type>> col_scaling_{};
194 array<index_type> permutation_array_{};
195
206 mutable struct cache_struct {
207 cache_struct() = default;
208
209 ~cache_struct() = default;
210
211 cache_struct(const cache_struct&) {}
212
213 cache_struct(cache_struct&&) {}
214
215 cache_struct& operator=(const cache_struct&) { return *this; }
216
217 cache_struct& operator=(cache_struct&&) { return *this; }
218
219 std::unique_ptr<matrix::Dense<value_type>> inner_b{};
220 std::unique_ptr<matrix::Dense<value_type>> inner_x{};
221 std::unique_ptr<matrix::Dense<value_type>> intermediate{};
222 } cache_;
223};
224
225
226} // namespace reorder
227} // namespace experimental
228} // namespace gko
229
230
231#endif // GKO_PUBLIC_CORE_REORDER_SCALED_REORDERED_HPP_
The AbstractFactory is a generic interface template that enables easy implementation of the abstract ...
Definition abstract_factory.hpp:47
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:662
Definition lin_op.hpp:117
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
const dim< 2 > & get_size() const noexcept
Returns the size of the operator.
Definition lin_op.hpp:210
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:234
Provides an interface to wrap reorderings like Rcm and diagonal scaling like equilibration around a L...
Definition scaled_reordered.hpp:45
static std::unique_ptr< Dense > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size={}, size_type stride=0)
Creates an uninitialized Dense matrix of the specified size.
static std::unique_ptr< Identity > create(std::shared_ptr< const Executor > exec, dim< 2 > size)
Creates an Identity matrix of the specified size.
#define GKO_CREATE_FACTORY_PARAMETERS(_parameters_name, _factory_name)
This Macro will generate a new type containing the parameters for the factory _factory_name.
Definition abstract_factory.hpp:280
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)
Creates a scalar factory parameter in the factory parameters structure.
Definition abstract_factory.hpp:445
#define GKO_ENABLE_BUILD_METHOD(_factory_name)
Defines a build method for the factory, simplifying its construction by removing the repetitive typin...
Definition abstract_factory.hpp:394
#define GKO_ENABLE_LIN_OP_FACTORY(_lin_op, _parameters_name, _factory_name)
This macro will generate a default implementation of a LinOpFactory for the LinOp subclass it is defi...
Definition lin_op.hpp:1017
The Ginkgo namespace.
Definition abstract_factory.hpp:20
detail::cloned_type< Pointer > clone(const Pointer &p)
Creates a unique clone of the object pointed to by p.
Definition utils_helper.hpp:173
std::decay_t< T > * as(U *obj)
Performs polymorphic type conversion.
Definition utils_helper.hpp:307
STL namespace.
std::shared_ptr< const ReorderingBaseFactory > reordering
The reordering that is to be applied to the system matrix.
Definition scaled_reordered.hpp:81
std::shared_ptr< const LinOpFactory > inner_operator
The inner operator factory that is to be generated on the scaled and reordered system matrix.
Definition scaled_reordered.hpp:73
std::shared_ptr< const matrix::Diagonal< value_type > > row_scaling
The row scaling that is to be applied to the system matrix.
Definition scaled_reordered.hpp:87
std::shared_ptr< const matrix::Diagonal< value_type > > col_scaling
The column scaling that is to be applied to the system matrix.
Definition scaled_reordered.hpp:93
This struct is used to pass parameters to the EnableDefaultReorderingBaseFactory::generate() method.
Definition reordering_base.hpp:65