Debian Codegraph @

src/atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h

raw
1 /*
2 * (C) Copyright 2024- ECMWF.
3 *
4 * This software is licensed under the terms of the Apache Licence Version 2.0
5 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6 * In applying this licence, ECMWF does not waive the privileges and immunities
7 * granted to it by virtue of its status as an intergovernmental organisation
8 * nor does it submit to any jurisdiction.
9 */
10
11 #pragma once
12
13 #include <any>
14 #include <memory>
15 #include <algorithm>
16 #include <type_traits>
17
18 #include "eckit/linalg/SparseMatrix.h"
19
20 #include "atlas/array.h"
21 #include "atlas/linalg/sparse/SparseMatrixStorage.h"
22
23 namespace atlas {
24 namespace linalg {
25
26 //----------------------------------------------------------------------------------------------------------------------
27
28 template<typename OutputT, typename InputT>
29 void host_copy_eckit (const InputT* input_data, array::Array& output) {
30 auto size = output.size();
31 OutputT* output_data = output.host_data<OutputT>();
32 std::copy( input_data, input_data + size, output_data );
33 }
34
35 inline SparseMatrixStorage make_sparse_matrix_storage(eckit::linalg::SparseMatrix&& m) {
36 using Index = eckit::linalg::Index;
37 using Value = eckit::linalg::Scalar;
38
39 std::size_t rows = m.rows();
40 std::size_t cols = m.cols();
41 std::size_t nnz = m.nonZeros();
42 array::Array* outer;
43 array::Array* inner;
44 array::Array* value;
45 {
46 array::label label{"sparse_matrix.outer"};
47 outer = array::Array::wrap(const_cast<Index*>(m.outer()), array::make_shape(rows+1));
48 }
49 {
50 array::label label{"sparse_matrix.inner"};
51 inner = array::Array::wrap(const_cast<Index*>(m.inner()), array::make_shape(nnz));
52 }
53 {
54 array::label label{"sparse_matrix.value"};
55 value = array::Array::wrap(const_cast<Value*>(m.data()), array::make_shape(nnz));
56 }
57
58 // We now move the eckit::linalg::SparseMatrix into a generic storage so
59 // the wrapped array data does not go out of scope
60 auto storage = std::make_any<eckit::linalg::SparseMatrix>(std::move(m));
61
62 return SparseMatrixStorage::make( rows, cols, nnz,
63 std::unique_ptr<array::Array>(value),
64 std::unique_ptr<array::Array>(inner),
65 std::unique_ptr<array::Array>(outer),
66 std::move(storage)
67 );
68 }
69
70 template< typename value_type, typename index_type = eckit::linalg::Index>
71 SparseMatrixStorage make_sparse_matrix_storage(eckit::linalg::SparseMatrix&& m) {
72 if (std::is_same_v<eckit::linalg::Scalar, value_type> && std::is_same_v<eckit::linalg::Index, index_type>) {
73 return make_sparse_matrix_storage(std::move(m));
74 }
75 std::size_t rows = m.rows();
76 std::size_t cols = m.cols();
77 std::size_t nnz = m.nonZeros();
78
79 array::Array* outer;
80 array::Array* inner;
81 array::Array* value;
82 {
83 array::label label{"sparse_matrix.outer"};
84 outer = array::Array::create<index_type>(rows+1);
85 }
86 {
87 array::label label{"sparse_matrix.inner"};
88 inner = array::Array::create<index_type>(nnz);
89 }
90 {
91 array::label label{"sparse_matrix.value"};
92 value = array::Array::create<value_type>(nnz);
93 }
94
95 host_copy_eckit<index_type>(m.outer(), *outer);
96 host_copy_eckit<index_type>(m.inner(), *inner);
97 host_copy_eckit<value_type>(m.data(), *value);
98
99 return SparseMatrixStorage::make( rows, cols, nnz,
100 std::unique_ptr<array::Array>(value),
101 std::unique_ptr<array::Array>(inner),
102 std::unique_ptr<array::Array>(outer),
103 std::any()
104 );
105 }
106
107
108 inline SparseMatrixStorage make_sparse_matrix_storage(const eckit::linalg::SparseMatrix& m) {
109 using Index = eckit::linalg::Index;
110 using Value = eckit::linalg::Scalar;
111
112 std::size_t rows = m.rows();
113 std::size_t cols = m.cols();
114 std::size_t nnz = m.nonZeros();
115
116 array::Array* outer;
117 array::Array* inner;
118 array::Array* value;
119 {
120 array::label label{"sparse_matrix.outer"};
121 outer = array::Array::create<Index>(rows+1);
122 }
123 {
124 array::label label{"sparse_matrix.inner"};
125 inner = array::Array::create<Index>(nnz);
126 }
127 {
128 array::label label{"sparse_matrix.value"};
129 value = array::Array::create<Value>(nnz);
130 }
131
132 host_copy_eckit<Index>(m.outer(), *outer);
133 host_copy_eckit<Index>(m.inner(), *inner);
134 host_copy_eckit<Value>(m.data(), *value);
135
136 return SparseMatrixStorage::make( rows, cols, nnz,
137 std::unique_ptr<array::Array>(value),
138 std::unique_ptr<array::Array>(inner),
139 std::unique_ptr<array::Array>(outer),
140 std::any()
141 );
142 }
143
144 template< typename value_type, typename index_type = eckit::linalg::Index>
145 SparseMatrixStorage make_sparse_matrix_storage(const eckit::linalg::SparseMatrix& m) {
146
147 std::size_t rows = m.rows();
148 std::size_t cols = m.cols();
149 std::size_t nnz = m.nonZeros();
150
151 array::Array* outer;
152 array::Array* inner;
153 array::Array* value;
154 {
155 array::label label{"sparse_matrix.outer"};
156 outer = array::Array::create<index_type>(rows+1);
157 }
158 {
159 array::label label{"sparse_matrix.inner"};
160 inner = array::Array::create<index_type>(nnz);
161 }
162 {
163 array::label label{"sparse_matrix.value"};
164 value = array::Array::create<value_type>(nnz);
165 }
166 host_copy_eckit<index_type>(m.outer(), *outer);
167 host_copy_eckit<index_type>(m.inner(), *inner);
168 host_copy_eckit<value_type>(m.data(), *value);
169
170 return SparseMatrixStorage::make( rows, cols, nnz,
171 std::unique_ptr<array::Array>(value),
172 std::unique_ptr<array::Array>(inner),
173 std::unique_ptr<array::Array>(outer),
174 std::any()
175 );
176 }
177
178 //----------------------------------------------------------------------------------------------------------------------
179
180 } // namespace linalg
181 } // namespace atlas