Ginkgo Generated from branch based on master. Ginkgo version 1.7.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
fbcsr.hpp
1/*******************************<GINKGO LICENSE>******************************
2Copyright (c) 2017-2023, the Ginkgo authors
3All rights reserved.
4
5Redistribution and use in source and binary forms, with or without
6modification, are permitted provided that the following conditions
7are met:
8
91. Redistributions of source code must retain the above copyright
10notice, this list of conditions and the following disclaimer.
11
122. Redistributions in binary form must reproduce the above copyright
13notice, this list of conditions and the following disclaimer in the
14documentation and/or other materials provided with the distribution.
15
163. Neither the name of the copyright holder nor the names of its
17contributors may be used to endorse or promote products derived from
18this software without specific prior written permission.
19
20THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
21IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
23PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31******************************<GINKGO LICENSE>*******************************/
32
33#ifndef GKO_PUBLIC_CORE_MATRIX_FBCSR_HPP_
34#define GKO_PUBLIC_CORE_MATRIX_FBCSR_HPP_
35
36
37#include <ginkgo/core/base/array.hpp>
38#include <ginkgo/core/base/lin_op.hpp>
39#include <ginkgo/core/base/math.hpp>
40
41
42namespace gko {
43namespace matrix {
44
45
46template <typename ValueType>
47class Dense;
48
49template <typename ValueType, typename IndexType>
50class Csr;
51
52template <typename ValueType, typename IndexType>
53class SparsityCsr;
54
55template <typename ValueType, typename IndexType>
56class Fbcsr;
57
58template <typename ValueType, typename IndexType>
60
61
62namespace detail {
63
64
75template <typename IndexType>
76inline IndexType get_num_blocks(const int block_size, const IndexType size)
77{
78 GKO_ASSERT_BLOCK_SIZE_CONFORMANT(size, block_size);
79 return size / block_size;
80}
81
82
83} // namespace detail
84
85
126template <typename ValueType = default_precision, typename IndexType = int32>
127class Fbcsr : public EnableLinOp<Fbcsr<ValueType, IndexType>>,
128 public EnableCreateMethod<Fbcsr<ValueType, IndexType>>,
129 public ConvertibleTo<Fbcsr<next_precision<ValueType>, IndexType>>,
130 public ConvertibleTo<Dense<ValueType>>,
131 public ConvertibleTo<Csr<ValueType, IndexType>>,
132 public ConvertibleTo<SparsityCsr<ValueType, IndexType>>,
133 public DiagonalExtractable<ValueType>,
134 public ReadableFromMatrixData<ValueType, IndexType>,
135 public WritableToMatrixData<ValueType, IndexType>,
136 public Transposable,
138 remove_complex<Fbcsr<ValueType, IndexType>>> {
139 friend class EnableCreateMethod<Fbcsr>;
140 friend class EnablePolymorphicObject<Fbcsr, LinOp>;
141 friend class Csr<ValueType, IndexType>;
142 friend class Dense<ValueType>;
143 friend class SparsityCsr<ValueType, IndexType>;
144 friend class FbcsrBuilder<ValueType, IndexType>;
145 friend class Fbcsr<to_complex<ValueType>, IndexType>;
146
147public:
148 using value_type = ValueType;
149 using index_type = IndexType;
153 using absolute_type = remove_complex<Fbcsr>;
154
161
166 using EnableLinOp<Fbcsr<ValueType, IndexType>>::convert_to;
167
168 using ConvertibleTo<
169 Fbcsr<next_precision<ValueType>, IndexType>>::convert_to;
170 using ConvertibleTo<Fbcsr<next_precision<ValueType>, IndexType>>::move_to;
171 using ConvertibleTo<Dense<ValueType>>::convert_to;
172 using ConvertibleTo<Dense<ValueType>>::move_to;
173 using ConvertibleTo<Csr<ValueType, IndexType>>::convert_to;
177
178 friend class Fbcsr<next_precision<ValueType>, IndexType>;
179
180 void convert_to(
181 Fbcsr<next_precision<ValueType>, IndexType>* result) const override;
182
183 void move_to(Fbcsr<next_precision<ValueType>, IndexType>* result) override;
184
185 void convert_to(Dense<ValueType>* other) const override;
186
187 void move_to(Dense<ValueType>* other) override;
188
196
197 void move_to(Csr<ValueType, IndexType>* result) override;
198
206
207 void move_to(SparsityCsr<ValueType, IndexType>* result) override;
208
215 void read(const mat_data& data) override;
216
217 void read(const device_mat_data& data) override;
218
219 void read(device_mat_data&& data) override;
220
221 void write(mat_data& data) const override;
222
223 std::unique_ptr<LinOp> transpose() const override;
224
225 std::unique_ptr<LinOp> conj_transpose() const override;
226
227 std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
228
229 std::unique_ptr<absolute_type> compute_absolute() const override;
230
232
238
246
250 value_type* get_values() noexcept { return values_.get_data(); }
251
259 const value_type* get_const_values() const noexcept
260 {
261 return values_.get_const_data();
262 }
263
267 index_type* get_col_idxs() noexcept { return col_idxs_.get_data(); }
268
277 {
278 return col_idxs_.get_const_data();
279 }
280
284 index_type* get_row_ptrs() noexcept { return row_ptrs_.get_data(); }
285
294 {
295 return row_ptrs_.get_const_data();
296 }
297
302 {
303 return values_.get_num_elems();
304 }
305
310 {
311 return col_idxs_.get_num_elems();
312 }
313
317 int get_block_size() const noexcept { return bs_; }
318
323 {
324 return this->get_size()[0] / bs_;
325 }
326
331 {
332 return this->get_size()[1] / bs_;
333 }
334
348 static std::unique_ptr<const Fbcsr> create_const(
349 std::shared_ptr<const Executor> exec, const dim<2>& size, int blocksize,
350 gko::detail::const_array_view<ValueType>&& values,
351 gko::detail::const_array_view<IndexType>&& col_idxs,
352 gko::detail::const_array_view<IndexType>&& row_ptrs)
353 {
354 // cast const-ness away, but return a const object afterwards,
355 // so we can ensure that no modifications take place.
356 return std::unique_ptr<const Fbcsr>(
357 new Fbcsr{exec, size, blocksize,
358 gko::detail::array_const_cast(std::move(values)),
359 gko::detail::array_const_cast(std::move(col_idxs)),
360 gko::detail::array_const_cast(std::move(row_ptrs))});
361 }
362
368
375
379 Fbcsr(const Fbcsr&);
380
387
388protected:
396 Fbcsr(std::shared_ptr<const Executor> exec, int block_size = 1)
397 : Fbcsr(std::move(exec), dim<2>{}, {}, block_size)
398 {}
399
409 Fbcsr(std::shared_ptr<const Executor> exec, const dim<2>& size,
411 : EnableLinOp<Fbcsr>(exec, size),
412 bs_{block_size},
413 values_(exec, num_nonzeros),
414 col_idxs_(exec, detail::get_num_blocks(block_size * block_size,
415 num_nonzeros)),
416 row_ptrs_(exec, detail::get_num_blocks(block_size, size[0]) + 1)
417 {
418 GKO_ASSERT_BLOCK_SIZE_CONFORMANT(size[1], bs_);
419 row_ptrs_.fill(0);
420 }
421
443 template <typename ValuesArray, typename ColIdxsArray,
444 typename RowPtrsArray>
445 Fbcsr(std::shared_ptr<const Executor> exec, const dim<2>& size,
446 int block_size, ValuesArray&& values, ColIdxsArray&& col_idxs,
448 : EnableLinOp<Fbcsr>(exec, size),
449 bs_{block_size},
450 values_{exec, std::forward<ValuesArray>(values)},
451 col_idxs_{exec, std::forward<ColIdxsArray>(col_idxs)},
452 row_ptrs_{exec, std::forward<RowPtrsArray>(row_ptrs)}
453 {
454 GKO_ASSERT_EQ(values_.get_num_elems(),
455 col_idxs_.get_num_elems() * bs_ * bs_);
456 GKO_ASSERT_EQ(this->get_size()[0] / bs_ + 1, row_ptrs_.get_num_elems());
457 }
458
459 void apply_impl(const LinOp* b, LinOp* x) const override;
460
461 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
462 LinOp* x) const override;
463
464private:
465 int bs_;
466 array<value_type> values_;
467 array<index_type> col_idxs_;
468 array<index_type> row_ptrs_;
469};
470
471
472} // namespace matrix
473} // namespace gko
474
475
476#endif // GKO_PUBLIC_CORE_MATRIX_FBCSR_HPP_
ConvertibleTo interface is used to mark that the implementer can be converted to the object of Result...
Definition polymorphic_object.hpp:499
The diagonal of a LinOp implementing this interface can be extracted.
Definition lin_op.hpp:772
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:823
This mixin implements a static create() method on ConcreteType that dynamically allocates the memory,...
Definition polymorphic_object.hpp:776
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:908
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:691
Definition lin_op.hpp:146
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:634
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:462
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:689
value_type * get_data() noexcept
Returns a pointer to the block of memory used to store the elements of the array.
Definition array.hpp:646
const value_type * get_const_data() const noexcept
Returns a constant pointer to the block of memory used to store the elements of the array.
Definition array.hpp:655
void fill(const value_type value)
Fill the array with the given value.
size_type get_num_elems() const noexcept
Returns the number of elements in the array.
Definition array.hpp:637
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:63
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:146
Dense is a matrix format which explicitly stores all values of the matrix.
Definition dense.hpp:136
Definition fbcsr.hpp:59
Fixed-block compressed sparse row storage matrix format.
Definition fbcsr.hpp:138
void read(device_mat_data &&data) override
Reads a matrix from a device_matrix_data structure.
size_type get_num_stored_blocks() const noexcept
Definition fbcsr.hpp:309
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
void read(const device_mat_data &data) override
Reads a matrix from a device_matrix_data structure.
size_type get_num_stored_elements() const noexcept
Definition fbcsr.hpp:301
const value_type * get_const_values() const noexcept
Definition fbcsr.hpp:259
const index_type * get_const_col_idxs() const noexcept
Definition fbcsr.hpp:276
index_type get_num_block_rows() const noexcept
Definition fbcsr.hpp:322
index_type * get_row_ptrs() noexcept
Definition fbcsr.hpp:284
int get_block_size() const noexcept
Definition fbcsr.hpp:317
index_type * get_col_idxs() noexcept
Definition fbcsr.hpp:267
Fbcsr(const Fbcsr &)
Copy-constructs an Ell matrix.
void write(mat_data &data) const override
Writes a matrix to a matrix_data structure.
static std::unique_ptr< const Fbcsr > create_const(std::shared_ptr< const Executor > exec, const dim< 2 > &size, int blocksize, gko::detail::const_array_view< ValueType > &&values, gko::detail::const_array_view< IndexType > &&col_idxs, gko::detail::const_array_view< IndexType > &&row_ptrs)
Creates a constant (immutable) Fbcsr matrix from a constant array.
Definition fbcsr.hpp:348
void compute_absolute_inplace() override
Compute absolute inplace on each element.
void sort_by_column_index()
Sorts the values blocks and block-column indices in each row by column index.
value_type * get_values() noexcept
Definition fbcsr.hpp:250
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
Fbcsr & operator=(Fbcsr &&)
Move-assigns an Fbcsr matrix.
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
Fbcsr(Fbcsr &&)
Move-constructs an Fbcsr matrix.
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.
const index_type * get_const_row_ptrs() const noexcept
Definition fbcsr.hpp:293
Fbcsr & operator=(const Fbcsr &)
Copy-assigns an Fbcsr matrix.
void convert_to(Csr< ValueType, IndexType > *result) const override
Converts the matrix to CSR format.
void read(const mat_data &data) override
Reads a matrix_data into Fbcsr format.
bool is_sorted_by_column_index() const
Tests if all row entry pairs (value, col_idx) are sorted by column index.
index_type get_num_block_cols() const noexcept
Definition fbcsr.hpp:330
void convert_to(SparsityCsr< ValueType, IndexType > *result) const override
Get the block sparsity pattern in CSR-like format.
SparsityCsr is a matrix format which stores only the sparsity pattern of a sparse matrix by compressi...
Definition sparsity_csr.hpp:87
The Ginkgo namespace.
Definition abstract_factory.hpp:48
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:803
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:354
typename detail::next_precision_impl< T >::type next_precision
Obtains the next type in the singly-linked precision list.
Definition math.hpp:490
typename detail::to_complex_s< T >::type to_complex
Obtain the type which adds the complex of complex/scalar type or the template parameter of class by a...
Definition math.hpp:373
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:120
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:55
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:155