|
Ginkgo
Generated from pipelines/1478841010 branch based on develop. Ginkgo version 1.9.0
A numerical linear algebra library targeting many-core architectures
|
5 #ifndef GKO_PUBLIC_CORE_MATRIX_HYBRID_HPP_
6 #define GKO_PUBLIC_CORE_MATRIX_HYBRID_HPP_
11 #include <ginkgo/core/base/array.hpp>
12 #include <ginkgo/core/base/lin_op.hpp>
13 #include <ginkgo/core/matrix/coo.hpp>
14 #include <ginkgo/core/matrix/csr.hpp>
15 #include <ginkgo/core/matrix/ell.hpp>
22 template <
typename ValueType>
25 template <
typename ValueType,
typename IndexType>
41 template <
typename ValueType = default_precision,
typename IndexType =
int32>
43 :
public EnableLinOp<Hybrid<ValueType, IndexType>>,
44 public ConvertibleTo<Hybrid<next_precision<ValueType>, IndexType>>,
45 public ConvertibleTo<Dense<ValueType>>,
46 public ConvertibleTo<Csr<ValueType, IndexType>>,
47 public DiagonalExtractable<ValueType>,
48 public ReadableFromMatrixData<ValueType, IndexType>,
49 public WritableToMatrixData<ValueType, IndexType>,
50 public EnableAbsoluteComputation<
51 remove_complex<Hybrid<ValueType, IndexType>>> {
52 friend class EnablePolymorphicObject<
Hybrid,
LinOp>;
53 friend class Dense<ValueType>;
54 friend class Csr<ValueType, IndexType>;
62 Hybrid<next_precision<ValueType>, IndexType>>::convert_to;
63 using ConvertibleTo<Hybrid<next_precision<ValueType>, IndexType>>::move_to;
64 using ConvertibleTo<Dense<ValueType>>::convert_to;
65 using ConvertibleTo<Dense<ValueType>>::move_to;
66 using ConvertibleTo<Csr<ValueType, IndexType>>::convert_to;
67 using ConvertibleTo<Csr<ValueType, IndexType>>::move_to;
70 using value_type = ValueType;
71 using index_type = IndexType;
72 using mat_data = matrix_data<ValueType, IndexType>;
73 using device_mat_data = device_matrix_data<ValueType, IndexType>;
74 using coo_type = Coo<ValueType, IndexType>;
75 using ell_type = Ell<ValueType, IndexType>;
76 using absolute_type = remove_complex<Hybrid>;
111 size_type* ell_num_stored_elements_per_row,
116 ref_row_nnz = row_nnz;
117 ell_num_stored_elements_per_row_ =
119 coo_nnz_ = this->compute_coo_nnz(ref_row_nnz);
120 *ell_num_stored_elements_per_row = ell_num_stored_elements_per_row_;
131 return ell_num_stored_elements_per_row_;
165 if (row_nnz_val[i] > ell_num_stored_elements_per_row_) {
167 row_nnz_val[i] - ell_num_stored_elements_per_row_;
174 size_type ell_num_stored_elements_per_row_;
190 : num_columns_(num_column)
227 percent_ = std::min(percent_, 1.0);
228 percent_ = std::max(percent_, 0.0);
234 auto row_nnz_val = row_nnz->
get_data();
235 auto num_rows = row_nnz->
get_size();
239 std::sort(row_nnz_val, row_nnz_val + num_rows);
241 auto percent_pos = static_cast<size_type>(num_rows * percent_);
242 return row_nnz_val[percent_pos];
244 return row_nnz_val[num_rows - 1];
276 auto num_rows = row_nnz->
get_size();
279 return std::min(ell_cols,
280 static_cast<size_type>(num_rows * ratio_));
316 (sizeof(ValueType) + 2 * sizeof(IndexType))))
373 void read(
const mat_data& data)
override;
375 void read(
const device_mat_data& data)
override;
377 void read(device_mat_data&& data)
override;
379 void write(mat_data& data)
const override;
403 return ell_->get_const_values();
422 return ell_->get_const_col_idxs();
432 return ell_->get_num_stored_elements_per_row();
449 return ell_->get_num_stored_elements();
465 return ell_->val_at(row, idx);
473 return ell_->val_at(row, idx);
488 return ell_->col_at(row, idx);
496 return ell_->col_at(row, idx);
522 return coo_->get_const_values();
541 return coo_->get_const_col_idxs();
560 return coo_->get_const_row_idxs();
570 return coo_->get_num_stored_elements();
587 return coo_->get_num_stored_elements() +
588 ell_->get_num_stored_elements();
608 template <
typename HybType>
609 std::shared_ptr<typename HybType::strategy_type>
get_strategy()
const;
621 static std::unique_ptr<Hybrid>
create(
622 std::shared_ptr<const Executor> exec,
623 std::shared_ptr<strategy_type> strategy =
624 std::make_shared<automatic>());
637 static std::unique_ptr<Hybrid>
create(
638 std::shared_ptr<const Executor> exec,
const dim<2>& size,
639 std::shared_ptr<strategy_type> strategy =
640 std::make_shared<automatic>());
654 static std::unique_ptr<Hybrid>
create(
655 std::shared_ptr<const Executor> exec,
const dim<2>& size,
657 std::shared_ptr<strategy_type> strategy =
658 std::make_shared<automatic>());
672 static std::unique_ptr<Hybrid>
create(
673 std::shared_ptr<const Executor> exec,
const dim<2>& size,
675 std::shared_ptr<strategy_type> strategy);
690 static std::unique_ptr<Hybrid>
create(
691 std::shared_ptr<const Executor> exec,
const dim<2>& size,
694 std::shared_ptr<strategy_type> strategy =
695 std::make_shared<automatic>());
724 Hybrid(std::shared_ptr<const Executor> exec,
const dim<2>& size = {},
727 std::shared_ptr<strategy_type> strategy =
728 std::make_shared<automatic>());
742 void apply_impl(
const LinOp* b,
LinOp* x)
const override;
745 LinOp* x)
const override;
748 std::unique_ptr<ell_type> ell_;
749 std::unique_ptr<coo_type> coo_;
750 std::shared_ptr<strategy_type> strategy_;
754 template <
typename ValueType,
typename IndexType>
755 template <
typename HybType>
756 std::shared_ptr<typename HybType::strategy_type>
760 std::is_same<HybType, Hybrid<
typename HybType::value_type,
761 typename HybType::index_type>>::value,
762 "The given `HybType` type must be of type `matrix::Hybrid`!");
764 std::shared_ptr<typename HybType::strategy_type> strategy;
765 if (std::dynamic_pointer_cast<automatic>(strategy_)) {
766 strategy = std::make_shared<typename HybType::automatic>();
767 }
else if (
auto temp = std::dynamic_pointer_cast<minimal_storage_limit>(
770 if (
sizeof(value_type) ==
sizeof(
typename HybType::value_type) &&
771 sizeof(index_type) ==
sizeof(
typename HybType::index_type)) {
773 std::make_shared<typename HybType::minimal_storage_limit>();
775 strategy = std::make_shared<typename HybType::imbalance_limit>(
776 temp->get_percentage());
778 }
else if (
auto temp = std::dynamic_pointer_cast<imbalance_bounded_limit>(
780 strategy = std::make_shared<typename HybType::imbalance_bounded_limit>(
781 temp->get_percentage(), temp->get_ratio());
782 }
else if (
auto temp =
783 std::dynamic_pointer_cast<imbalance_limit>(strategy_)) {
784 strategy = std::make_shared<typename HybType::imbalance_limit>(
785 temp->get_percentage());
786 }
else if (
auto temp = std::dynamic_pointer_cast<column_limit>(strategy_)) {
787 strategy = std::make_shared<typename HybType::column_limit>(
788 temp->get_num_columns());
790 GKO_NOT_SUPPORTED(strategy_);
800 #endif // GKO_PUBLIC_CORE_MATRIX_HYBRID_HPP_
const value_type * get_const_coo_values() const noexcept
Returns the values of the coo part.
Definition: hybrid.hpp:520
index_type ell_col_at(size_type row, size_type idx) const noexcept
Returns the idx-th column index of the row-th row in the ell part.
Definition: hybrid.hpp:494
size_type get_ell_num_stored_elements_per_row() const noexcept
Returns the number of stored elements per row of ell part.
Definition: hybrid.hpp:430
const index_type * get_const_coo_row_idxs() const noexcept
Returns the row indexes of the coo part.
Definition: hybrid.hpp:558
minimal_storage_limit()
Creates a minimal_storage_limit strategy.
Definition: hybrid.hpp:313
void move_to(result_type *result) override
Definition: polymorphic_object.hpp:731
void convert_to(result_type *result) const override
Definition: polymorphic_object.hpp:729
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition: matrix.hpp:27
imbalance_bounded_limit(double percent=0.8, double ratio=0.0001)
Creates a imbalance_bounded_limit strategy.
Definition: hybrid.hpp:269
column_limit is a strategy_type which decides the number of stored elements per row of the ell part b...
Definition: hybrid.hpp:182
size_type compute_ell_num_stored_elements_per_row(array< size_type > *row_nnz) const override
Computes the number of stored elements per row of the ell part.
Definition: hybrid.hpp:348
auto get_percentage() const
Get the percent setting.
Definition: hybrid.hpp:253
virtual void read(const matrix_data< ValueType, IndexType > &data)=0
Reads a matrix from a matrix_data structure.
Dense is a matrix format which explicitly stores all values of the matrix.
Definition: dense_cache.hpp:19
strategy_type is to decide how to set the hybrid config.
Definition: hybrid.hpp:88
void compute_hybrid_config(const array< size_type > &row_nnz, size_type *ell_num_stored_elements_per_row, size_type *coo_nnz)
Computes the config of the Hybrid matrix (ell_num_stored_elements_per_row and coo_nnz).
Definition: hybrid.hpp:110
index_type & ell_col_at(size_type row, size_type idx) noexcept
Returns the idx-th column index of the row-th row in the ell part.
Definition: hybrid.hpp:486
const ell_type * get_ell() const noexcept
Returns the matrix of the ell part.
Definition: hybrid.hpp:504
value_type * get_coo_values() noexcept
Returns the values of the coo part.
Definition: hybrid.hpp:511
index_type * get_ell_col_idxs() noexcept
Returns the column indexes of the ell part.
Definition: hybrid.hpp:411
size_type get_ell_num_stored_elements_per_row() const noexcept
Returns the number of stored elements per row of the ell part.
Definition: hybrid.hpp:129
size_type compute_ell_num_stored_elements_per_row(array< size_type > *row_nnz) const override
Computes the number of stored elements per row of the ell part.
Definition: hybrid.hpp:193
value_type * get_ell_values() noexcept
Returns the values of the ell part.
Definition: hybrid.hpp:392
automatic is a strategy_type which decides the number of stored elements per row of the ell part auto...
Definition: hybrid.hpp:341
size_type get_coo_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the coo part.
Definition: hybrid.hpp:568
std::size_t size_type
Integral type used for allocation quantities.
Definition: types.hpp:86
void read(const mat_data &data) override
Reads a matrix from a matrix_data structure.
index_type * get_coo_row_idxs() noexcept
Returns the row indexes of the coo part.
Definition: hybrid.hpp:549
auto get_percentage() const
Get the percent setting.
Definition: hybrid.hpp:330
size_type get_ell_stride() const noexcept
Returns the stride of the ell part.
Definition: hybrid.hpp:440
const value_type * get_const_ell_values() const noexcept
Returns the values of the ell part.
Definition: hybrid.hpp:401
The Ginkgo namespace.
Definition: abstract_factory.hpp:20
size_type compute_ell_num_stored_elements_per_row(array< size_type > *row_nnz) const override
Computes the number of stored elements per row of the ell part.
Definition: hybrid.hpp:319
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition: hybrid.hpp:585
index_type * get_coo_col_idxs() noexcept
Returns the column indexes of the coo part.
Definition: hybrid.hpp:530
const index_type * get_const_coo_col_idxs() const noexcept
Returns the column indexes of the coo part.
Definition: hybrid.hpp:539
virtual size_type compute_ell_num_stored_elements_per_row(array< size_type > *row_nnz) const =0
Computes the number of stored elements per row of the ell part.
size_type get_coo_nnz() const noexcept
Returns the number of nonzeros of the coo part.
Definition: hybrid.hpp:139
size_type compute_ell_num_stored_elements_per_row(array< size_type > *row_nnz) const override
Computes the number of stored elements per row of the ell part.
Definition: hybrid.hpp:231
imbalance_bounded_limit is a strategy_type which decides the number of stored elements per row of the...
Definition: hybrid.hpp:264
typename detail::next_precision_impl< T >::type next_precision
Obtains the next type in the singly-linked precision list.
Definition: math.hpp:461
value_type * get_data() noexcept
Returns a pointer to the block of memory used to store the elements of the array.
Definition: array.hpp:673
std::shared_ptr< strategy_type > get_strategy() const noexcept
Returns the strategy.
Definition: hybrid.hpp:596
static std::unique_ptr< Hybrid > create(std::shared_ptr< const Executor > exec, std::shared_ptr< strategy_type > strategy=std::make_shared< automatic >())
Creates an uninitialized Hybrid matrix of specified method.
strategy_type()
Creates a strategy_type.
Definition: hybrid.hpp:93
automatic()
Creates an automatic strategy.
Definition: hybrid.hpp:346
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor associated with the array.
Definition: array.hpp:689
const index_type * get_const_ell_col_idxs() const noexcept
Returns the column indexes of the ell part.
Definition: hybrid.hpp:420
void compute_absolute_inplace() override
Compute absolute inplace on each element.
auto get_num_columns() const
Get the number of columns limit.
Definition: hybrid.hpp:204
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
column_limit(size_type num_column=0)
Creates a column_limit strategy.
Definition: hybrid.hpp:189
value_type & ell_val_at(size_type row, size_type idx) noexcept
Returns the idx-th non-zero element of the row-th row in the ell part.
Definition: hybrid.hpp:463
void write(mat_data &data) const override
Writes a matrix to a matrix_data structure.
imbalance_limit is a strategy_type which decides the number of stored elements per row of the ell par...
Definition: hybrid.hpp:217
ELL is a matrix format where stride with explicit zeros is used such that all rows have the same numb...
Definition: csr.hpp:31
Hybrid(const Hybrid &)
Copy-assigns a Hybrid matrix.
value_type ell_val_at(size_type row, size_type idx) const noexcept
Returns the idx-th non-zero element of the row-th row in the ell part.
Definition: hybrid.hpp:471
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition: coo.hpp:32
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:682
size_type get_ell_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the ell part.
Definition: hybrid.hpp:447
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.
size_type get_size() const noexcept
Returns the number of elements in the array.
Definition: array.hpp:656
const coo_type * get_coo() const noexcept
Returns the matrix of the coo part.
Definition: hybrid.hpp:578
imbalance_limit(double percent=0.8)
Creates a imbalance_limit strategy.
Definition: hybrid.hpp:225
auto get_percentage() const
Get the percent setting.
Definition: hybrid.hpp:288
minimal_storage_limit is a strategy_type which decides the number of stored elements per row of the e...
Definition: hybrid.hpp:308
size_type compute_ell_num_stored_elements_per_row(array< size_type > *row_nnz) const override
Computes the number of stored elements per row of the ell part.
Definition: hybrid.hpp:273
auto get_ratio() const
Get the ratio setting.
Definition: hybrid.hpp:295
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
Hybrid & operator=(const Hybrid &)
Copy-assigns a Hybrid matrix.
constexpr T zero()
Returns the additive identity for T.
Definition: math.hpp:746
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:344
COO stores a matrix in the coordinate matrix format.
Definition: coo.hpp:50