ViennaCL - The Vienna Computing Library: viennacl/coordinate_matrix.hpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
coordinate_matrix.hpp
Go to the documentation of this file.
1 #ifndef VIENNACL_COORDINATE_MATRIX_HPP_
2 #define VIENNACL_COORDINATE_MATRIX_HPP_
3
4 /* =========================================================================
5 Copyright (c) 2010-2016, Institute for Microelectronics,
6 Institute for Analysis and Scientific Computing,
7 TU Wien.
8 Portions of this software are copyright by UChicago Argonne, LLC.
9
10 -----------------
11 ViennaCL - The Vienna Computing Library
12 -----------------
13
14 Project Head: Karl Rupp rupp@iue.tuwien.ac.at
15
16 (A list of authors and contributors can be found in the manual)
17
18 License: MIT (X11), see file LICENSE in the base directory
19 ============================================================================= */
20
25 #include <map>
26 #include <vector>
27 #include <list>
28
29 #include "viennacl/forwards.h"
30 #include "viennacl/vector.hpp"
31
32 #include "viennacl/linalg/sparse_matrix_operations.hpp"
33
34 namespace viennacl
35 {
36
37
38 //provide copy-operation:
46 template<typename CPUMatrixT, typename NumericT, unsigned int AlignmentV>
47 void copy(const CPUMatrixT & cpu_matrix,
48 coordinate_matrix<NumericT, AlignmentV> & gpu_matrix )
49 {
50 assert( (gpu_matrix.size1() == 0 || viennacl::traits::size1(cpu_matrix) == gpu_matrix.size1()) && bool("Size mismatch") );
51 assert( (gpu_matrix.size2() == 0 || viennacl::traits::size2(cpu_matrix) == gpu_matrix.size2()) && bool("Size mismatch") );
52
53 vcl_size_t group_num = 64;
54
55 // Step 1: Determine nonzeros:
56 if ( cpu_matrix.size1() > 0 && cpu_matrix.size2() > 0 )
57 {
58 vcl_size_t num_entries = 0;
59 for (typename CPUMatrixT::const_iterator1 row_it = cpu_matrix.begin1(); row_it != cpu_matrix.end1(); ++row_it)
60 for (typename CPUMatrixT::const_iterator2 col_it = row_it.begin(); col_it != row_it.end(); ++col_it)
61 ++num_entries;
62
63 // Step 2: Set up matrix data:
64 gpu_matrix.nonzeros_ = num_entries;
65 gpu_matrix.rows_ = cpu_matrix.size1();
66 gpu_matrix.cols_ = cpu_matrix.size2();
67
68 viennacl::backend::typesafe_host_array<unsigned int> group_boundaries(gpu_matrix.handle3(), group_num + 1);
69 viennacl::backend::typesafe_host_array<unsigned int> coord_buffer(gpu_matrix.handle12(), 2*gpu_matrix.internal_nnz());
70 std::vector<NumericT> elements(gpu_matrix.internal_nnz());
71
72 vcl_size_t data_index = 0;
73 vcl_size_t current_fraction = 0;
74
75 group_boundaries.set(0, 0);
76 for (typename CPUMatrixT::const_iterator1 row_it = cpu_matrix.begin1(); row_it != cpu_matrix.end1(); ++row_it)
77 {
78 for (typename CPUMatrixT::const_iterator2 col_it = row_it.begin(); col_it != row_it.end(); ++col_it)
79 {
80 coord_buffer.set(2*data_index, col_it.index1());
81 coord_buffer.set(2*data_index + 1, col_it.index2());
82 elements[data_index] = *col_it;
83 ++data_index;
84 }
85
86 while (data_index > vcl_size_t(static_cast<double>(current_fraction + 1) / static_cast<double>(group_num)) * num_entries) //split data equally over 64 groups
87 group_boundaries.set(++current_fraction, data_index);
88 }
89
90 //write end of last group:
91 group_boundaries.set(group_num, data_index);
92 //group_boundaries[1] = data_index; //for one compute unit
93
94 //std::cout << "Group boundaries: " << std::endl;
95 //for (vcl_size_t i=0; i<group_boundaries.size(); ++i)
96 // std::cout << group_boundaries[i] << std::endl;
97
98 viennacl::backend::memory_create(gpu_matrix.group_boundaries_, group_boundaries.raw_size(), traits::context(gpu_matrix.group_boundaries_), group_boundaries.get());
99 viennacl::backend::memory_create(gpu_matrix.coord_buffer_, coord_buffer.raw_size(), traits::context(gpu_matrix.coord_buffer_), coord_buffer.get());
100 viennacl::backend::memory_create(gpu_matrix.elements_, sizeof(NumericT)*elements.size(), traits::context(gpu_matrix.elements_), &(elements[0]));
101 }
102 }
103
109 template<typename NumericT, unsigned int AlignmentV>
110 void copy(const std::vector< std::map<unsigned int, NumericT> > & cpu_matrix,
111 coordinate_matrix<NumericT, AlignmentV> & gpu_matrix )
112 {
113 vcl_size_t max_col = 0;
114 for (vcl_size_t i=0; i<cpu_matrix.size(); ++i)
115 {
116 if (cpu_matrix[i].size() > 0)
117 max_col = std::max<vcl_size_t>(max_col, (cpu_matrix[i].rbegin())->first);
118 }
119
120 viennacl::copy(tools::const_sparse_matrix_adapter<NumericT>(cpu_matrix, cpu_matrix.size(), max_col + 1), gpu_matrix);
121 }
122
123 //gpu to cpu:
133 template<typename CPUMatrixT, typename NumericT, unsigned int AlignmentV>
134 void copy(const coordinate_matrix<NumericT, AlignmentV> & gpu_matrix,
135 CPUMatrixT & cpu_matrix )
136 {
137 assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix.size1()) && bool("Size mismatch") );
138 assert( (viennacl::traits::size2(cpu_matrix) == gpu_matrix.size2()) && bool("Size mismatch") );
139
140 if ( gpu_matrix.size1() > 0 && gpu_matrix.size2() > 0 )
141 {
142 //get raw data from memory:
143 viennacl::backend::typesafe_host_array<unsigned int> coord_buffer(gpu_matrix.handle12(), 2*gpu_matrix.nnz());
144 std::vector<NumericT> elements(gpu_matrix.nnz());
145
146 //std::cout << "GPU nonzeros: " << gpu_matrix.nnz() << std::endl;
147
148 viennacl::backend::memory_read(gpu_matrix.handle12(), 0, coord_buffer.raw_size(), coord_buffer.get());
149 viennacl::backend::memory_read(gpu_matrix.handle(), 0, sizeof(NumericT) * elements.size(), &(elements[0]));
150
151 //fill the cpu_matrix:
152 for (vcl_size_t index = 0; index < gpu_matrix.nnz(); ++index)
153 cpu_matrix(coord_buffer[2*index], coord_buffer[2*index+1]) = elements[index];
154
155 }
156 }
157
163 template<typename NumericT, unsigned int AlignmentV>
164 void copy(const coordinate_matrix<NumericT, AlignmentV> & gpu_matrix,
165 std::vector< std::map<unsigned int, NumericT> > & cpu_matrix)
166 {
167 if (cpu_matrix.size() == 0)
168 cpu_matrix.resize(gpu_matrix.size1());
169
170 assert(cpu_matrix.size() == gpu_matrix.size1() && bool("Matrix dimension mismatch!"));
171
172 tools::sparse_matrix_adapter<NumericT> temp(cpu_matrix, gpu_matrix.size1(), gpu_matrix.size2());
173 copy(gpu_matrix, temp);
174 }
175
176
178
185 template<class NumericT, unsigned int AlignmentV /* see forwards.h */ >
186 class coordinate_matrix
187 {
188 public:
189 typedef viennacl::backend::mem_handle handle_type;
190 typedef scalar<typename viennacl::tools::CHECK_SCALAR_TEMPLATE_ARGUMENT<NumericT>::ResultType> value_type;
191 typedef vcl_size_t size_type;
192
194 coordinate_matrix() : rows_(0), cols_(0), nonzeros_(0), group_num_(64) {}
195
196 explicit coordinate_matrix(viennacl::context ctx) : rows_(0), cols_(0), nonzeros_(0), group_num_(64)
197 {
198 group_boundaries_.switch_active_handle_id(ctx.memory_type());
199 coord_buffer_.switch_active_handle_id(ctx.memory_type());
200 elements_.switch_active_handle_id(ctx.memory_type());
201
202 #ifdef VIENNACL_WITH_OPENCL
203 if (ctx.memory_type() == OPENCL_MEMORY)
204 {
205 group_boundaries_.opencl_handle().context(ctx.opencl_context());
206 coord_buffer_.opencl_handle().context(ctx.opencl_context());
207 elements_.opencl_handle().context(ctx.opencl_context());
208 }
209 #endif
210 }
211
219 coordinate_matrix(vcl_size_t rows, vcl_size_t cols, vcl_size_t nonzeros = 0, viennacl::context ctx = viennacl::context()) :
220 rows_(rows), cols_(cols), nonzeros_(nonzeros)
221 {
222 if (nonzeros > 0)
223 {
224 viennacl::backend::memory_create(group_boundaries_, viennacl::backend::typesafe_host_array<unsigned int>().element_size() * (group_num_ + 1), ctx);
225 viennacl::backend::memory_create(coord_buffer_, viennacl::backend::typesafe_host_array<unsigned int>().element_size() * 2 * internal_nnz(), ctx);
226 viennacl::backend::memory_create(elements_, sizeof(NumericT) * internal_nnz(), ctx);
227 }
228 else
229 {
230 group_boundaries_.switch_active_handle_id(ctx.memory_type());
231 coord_buffer_.switch_active_handle_id(ctx.memory_type());
232 elements_.switch_active_handle_id(ctx.memory_type());
233
234 #ifdef VIENNACL_WITH_OPENCL
235 if (ctx.memory_type() == OPENCL_MEMORY)
236 {
237 group_boundaries_.opencl_handle().context(ctx.opencl_context());
238 coord_buffer_.opencl_handle().context(ctx.opencl_context());
239 elements_.opencl_handle().context(ctx.opencl_context());
240 }
241 #endif
242 }
243 }
244
251 explicit coordinate_matrix(vcl_size_t rows, vcl_size_t cols, viennacl::context ctx)
252 : rows_(rows), cols_(cols), nonzeros_(0)
253 {
254 group_boundaries_.switch_active_handle_id(ctx.memory_type());
255 coord_buffer_.switch_active_handle_id(ctx.memory_type());
256 elements_.switch_active_handle_id(ctx.memory_type());
257
258 #ifdef VIENNACL_WITH_OPENCL
259 if (ctx.memory_type() == OPENCL_MEMORY)
260 {
261 group_boundaries_.opencl_handle().context(ctx.opencl_context());
262 coord_buffer_.opencl_handle().context(ctx.opencl_context());
263 elements_.opencl_handle().context(ctx.opencl_context());
264 }
265 #endif
266 }
267
268
270 void reserve(vcl_size_t new_nonzeros)
271 {
272 if (new_nonzeros > nonzeros_) //TODO: Do we need to initialize new memory with zero?
273 {
274 handle_type coord_buffer_old;
275 handle_type elements_old;
276 viennacl::backend::memory_shallow_copy(coord_buffer_, coord_buffer_old);
277 viennacl::backend::memory_shallow_copy(elements_, elements_old);
278
279 vcl_size_t internal_new_nnz = viennacl::tools::align_to_multiple<vcl_size_t>(new_nonzeros, AlignmentV);
280 viennacl::backend::typesafe_host_array<unsigned int> size_deducer(coord_buffer_);
281 viennacl::backend::memory_create(coord_buffer_, size_deducer.element_size() * 2 * internal_new_nnz, viennacl::traits::context(coord_buffer_));
282 viennacl::backend::memory_create(elements_, sizeof(NumericT) * internal_new_nnz, viennacl::traits::context(elements_));
283
284 viennacl::backend::memory_copy(coord_buffer_old, coord_buffer_, 0, 0, size_deducer.element_size() * 2 * nonzeros_);
285 viennacl::backend::memory_copy(elements_old, elements_, 0, 0, sizeof(NumericT) * nonzeros_);
286
287 nonzeros_ = new_nonzeros;
288 }
289 }
290
297 void resize(vcl_size_t new_size1, vcl_size_t new_size2, bool preserve = true)
298 {
299 assert (new_size1 > 0 && new_size2 > 0);
300
301 if (new_size1 < rows_ || new_size2 < cols_) //enlarge buffer
302 {
303 std::vector<std::map<unsigned int, NumericT> > stl_sparse_matrix;
304 if (rows_ > 0)
305 stl_sparse_matrix.resize(rows_);
306
307 if (preserve && rows_ > 0)
308 viennacl::copy(*this, stl_sparse_matrix);
309
310 stl_sparse_matrix.resize(new_size1);
311
312 //std::cout << "Cropping STL matrix of size " << stl_sparse_matrix.size() << std::endl;
313 if (new_size2 < cols_ && rows_ > 0)
314 {
315 for (vcl_size_t i=0; i<stl_sparse_matrix.size(); ++i)
316 {
317 std::list<unsigned int> to_delete;
318 for (typename std::map<unsigned int, NumericT>::iterator it = stl_sparse_matrix[i].begin();
319 it != stl_sparse_matrix[i].end();
320 ++it)
321 {
322 if (it->first >= new_size2)
323 to_delete.push_back(it->first);
324 }
325
326 for (std::list<unsigned int>::iterator it = to_delete.begin(); it != to_delete.end(); ++it)
327 stl_sparse_matrix[i].erase(*it);
328 }
329 //std::cout << "Cropping done..." << std::endl;
330 }
331
332 rows_ = new_size1;
333 cols_ = new_size2;
334 viennacl::copy(stl_sparse_matrix, *this);
335 }
336
337 rows_ = new_size1;
338 cols_ = new_size2;
339 }
340
342 void clear()
343 {
344 viennacl::backend::typesafe_host_array<unsigned int> host_group_buffer(group_boundaries_, 65);
345 viennacl::backend::typesafe_host_array<unsigned int> host_coord_buffer(coord_buffer_, 2);
346 std::vector<NumericT> host_elements(1);
347
348 viennacl::backend::memory_create(group_boundaries_, host_group_buffer.element_size() * 65, viennacl::traits::context(group_boundaries_), host_group_buffer.get());
349 viennacl::backend::memory_create(coord_buffer_, host_coord_buffer.element_size() * 2, viennacl::traits::context(coord_buffer_), host_coord_buffer.get());
350 viennacl::backend::memory_create(elements_, sizeof(NumericT) * 1, viennacl::traits::context(elements_), &(host_elements[0]));
351
352 nonzeros_ = 0;
353 group_num_ = 64;
354 }
355
357 vcl_size_t size1() const { return rows_; }
359 vcl_size_t size2() const { return cols_; }
361 vcl_size_t nnz() const { return nonzeros_; }
363 vcl_size_t internal_nnz() const { return viennacl::tools::align_to_multiple<vcl_size_t>(nonzeros_, AlignmentV); }
364
366 const handle_type & handle12() const { return coord_buffer_; }
368 const handle_type & handle() const { return elements_; }
370 const handle_type & handle3() const { return group_boundaries_; }
371
372 vcl_size_t groups() const { return group_num_; }
373
374 #if defined(_MSC_VER) && _MSC_VER < 1500 //Visual Studio 2005 needs special treatment
375 template<typename CPUMatrixT>
376 friend void copy(const CPUMatrixT & cpu_matrix, coordinate_matrix & gpu_matrix );
377 #else
378 template<typename CPUMatrixT, typename NumericT2, unsigned int AlignmentV2>
379 friend void copy(const CPUMatrixT & cpu_matrix, coordinate_matrix<NumericT2, AlignmentV2> & gpu_matrix );
380 #endif
381
382 private:
384 coordinate_matrix(coordinate_matrix const &);
385
387 coordinate_matrix & operator=(coordinate_matrix const &);
388
389
390 vcl_size_t rows_;
391 vcl_size_t cols_;
392 vcl_size_t nonzeros_;
393 vcl_size_t group_num_;
394 handle_type coord_buffer_;
395 handle_type elements_;
396 handle_type group_boundaries_;
397 };
398
399
400 //
401 // Specify available operations:
402 //
403
406 namespace linalg
407 {
408 namespace detail
409 {
410 // x = A * y
411 template<typename T, unsigned int A>
412 struct op_executor<vector_base<T>, op_assign, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> >
413 {
414 static void apply(vector_base<T> & lhs, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> const & rhs)
415 {
416 // check for the special case x = A * x
417 if (viennacl::traits::handle(lhs) == viennacl::traits::handle(rhs.rhs()))
418 {
419 viennacl::vector<T> temp(lhs);
420 viennacl::linalg::prod_impl(rhs.lhs(), rhs.rhs(), T(1), temp, T(0));
421 lhs = temp;
422 }
423 else
424 viennacl::linalg::prod_impl(rhs.lhs(), rhs.rhs(), T(1), lhs, T(0));
425 }
426 };
427
428 template<typename T, unsigned int A>
429 struct op_executor<vector_base<T>, op_inplace_add, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> >
430 {
431 static void apply(vector_base<T> & lhs, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> const & rhs)
432 {
433 // check for the special case x += A * x
434 if (viennacl::traits::handle(lhs) == viennacl::traits::handle(rhs.rhs()))
435 {
436 viennacl::vector<T> temp(lhs);
437 viennacl::linalg::prod_impl(rhs.lhs(), rhs.rhs(), T(1), temp, T(0));
438 lhs += temp;
439 }
440 else
441 viennacl::linalg::prod_impl(rhs.lhs(), rhs.rhs(), T(1), lhs, T(1));
442 }
443 };
444
445 template<typename T, unsigned int A>
446 struct op_executor<vector_base<T>, op_inplace_sub, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> >
447 {
448 static void apply(vector_base<T> & lhs, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> const & rhs)
449 {
450 // check for the special case x -= A * x
451 if (viennacl::traits::handle(lhs) == viennacl::traits::handle(rhs.rhs()))
452 {
453 viennacl::vector<T> temp(lhs);
454 viennacl::linalg::prod_impl(rhs.lhs(), rhs.rhs(), T(1), temp, T(0));
455 lhs -= temp;
456 }
457 else
458 viennacl::linalg::prod_impl(rhs.lhs(), rhs.rhs(), T(-1), lhs, T(1));
459 }
460 };
461
462
463 // x = A * vec_op
464 template<typename T, unsigned int A, typename LHS, typename RHS, typename OP>
465 struct op_executor<vector_base<T>, op_assign, vector_expression<const coordinate_matrix<T, A>, const vector_expression<const LHS, const RHS, OP>, op_prod> >
466 {
467 static void apply(vector_base<T> & lhs, vector_expression<const coordinate_matrix<T, A>, const vector_expression<const LHS, const RHS, OP>, op_prod> const & rhs)
468 {
469 viennacl::vector<T> temp(rhs.rhs(), viennacl::traits::context(rhs));
470 viennacl::linalg::prod_impl(rhs.lhs(), temp, lhs);
471 }
472 };
473
474 // x += A * vec_op
475 template<typename T, unsigned int A, typename LHS, typename RHS, typename OP>
476 struct op_executor<vector_base<T>, op_inplace_add, vector_expression<const coordinate_matrix<T, A>, const vector_expression<const LHS, const RHS, OP>, op_prod> >
477 {
478 static void apply(vector_base<T> & lhs, vector_expression<const coordinate_matrix<T, A>, const vector_expression<const LHS, const RHS, OP>, op_prod> const & rhs)
479 {
480 viennacl::vector<T> temp(rhs.rhs(), viennacl::traits::context(rhs));
481 viennacl::vector<T> temp_result(lhs);
482 viennacl::linalg::prod_impl(rhs.lhs(), temp, temp_result);
483 lhs += temp_result;
484 }
485 };
486
487 // x -= A * vec_op
488 template<typename T, unsigned int A, typename LHS, typename RHS, typename OP>
489 struct op_executor<vector_base<T>, op_inplace_sub, vector_expression<const coordinate_matrix<T, A>, const vector_expression<const LHS, const RHS, OP>, op_prod> >
490 {
491 static void apply(vector_base<T> & lhs, vector_expression<const coordinate_matrix<T, A>, const vector_expression<const LHS, const RHS, OP>, op_prod> const & rhs)
492 {
493 viennacl::vector<T> temp(rhs.rhs(), viennacl::traits::context(rhs));
494 viennacl::vector<T> temp_result(lhs);
495 viennacl::linalg::prod_impl(rhs.lhs(), temp, temp_result);
496 lhs -= temp_result;
497 }
498 };
499
500 } // namespace detail
501 } // namespace linalg
502
504 }
505
506 #endif
viennacl::backend::typesafe_host_array
Helper class implementing an array on the host. Default case: No conversion necessary.
Definition: util.hpp:92
viennacl::backend::typesafe_host_array::element_size
vcl_size_t element_size() const
Definition: util.hpp:112
viennacl::scalar
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Definition: forwards.h:227
viennacl::coordinate_matrix::handle12
const handle_type & handle12() const
Returns the OpenCL handle to the (row, column) index array.
Definition: coordinate_matrix.hpp:366
viennacl::traits::size1
vcl_size_t size1(MatrixType const &mat)
Generic routine for obtaining the number of rows of a matrix (ViennaCL, uBLAS, etc.)
Definition: size.hpp:163
viennacl::coordinate_matrix::coordinate_matrix
coordinate_matrix(viennacl::context ctx)
Definition: coordinate_matrix.hpp:196
viennacl::coordinate_matrix::coordinate_matrix
coordinate_matrix()
Default construction of a coordinate matrix. No memory is allocated.
Definition: coordinate_matrix.hpp:194
viennacl::OPENCL_MEMORY
Definition: forwards.h:349
forwards.h
This file provides the forward declarations for the main types used within ViennaCL.
viennacl::coordinate_matrix::nnz
vcl_size_t nnz() const
Returns the number of nonzero entries.
Definition: coordinate_matrix.hpp:361
viennacl::backend::typesafe_host_array::get
void * get()
Definition: util.hpp:110
viennacl::backend::memory_read
void memory_read(mem_handle const &src_buffer, vcl_size_t src_offset, vcl_size_t bytes_to_read, void *ptr, bool async=false)
Reads data from a buffer back to main RAM.
Definition: memory.hpp:261
viennacl::coordinate_matrix::resize
void resize(vcl_size_t new_size1, vcl_size_t new_size2, bool preserve=true)
Resize the matrix.
Definition: coordinate_matrix.hpp:297
viennacl::traits::size2
result_of::size_type< MatrixType >::type size2(MatrixType const &mat)
Generic routine for obtaining the number of columns of a matrix (ViennaCL, uBLAS, etc...
Definition: size.hpp:201
viennacl::backend::detail::element_size
vcl_size_t element_size(memory_types)
Definition: memory.hpp:299
NumericT
float NumericT
Definition: bisect.cpp:40
viennacl::context
Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also su...
Definition: context.hpp:39
viennacl::coordinate_matrix::internal_nnz
vcl_size_t internal_nnz() const
Returns the number of internal nonzero entries.
Definition: coordinate_matrix.hpp:363
viennacl::coordinate_matrix::coordinate_matrix
coordinate_matrix(vcl_size_t rows, vcl_size_t cols, vcl_size_t nonzeros=0, viennacl::context ctx=viennacl::context())
Construction of a coordinate matrix with the supplied number of rows and columns. If the number of no...
Definition: coordinate_matrix.hpp:219
viennacl::traits::size
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Definition: size.hpp:239
viennacl::coordinate_matrix::size2
vcl_size_t size2() const
Returns the number of columns.
Definition: coordinate_matrix.hpp:359
viennacl::coordinate_matrix::value_type
scalar< typename viennacl::tools::CHECK_SCALAR_TEMPLATE_ARGUMENT< NumericT >::ResultType > value_type
Definition: coordinate_matrix.hpp:190
viennacl::coordinate_matrix::size_type
vcl_size_t size_type
Definition: coordinate_matrix.hpp:191
sparse_matrix_operations.hpp
Implementations of operations using sparse matrices.
viennacl::coordinate_matrix::handle_type
viennacl::backend::mem_handle handle_type
Definition: coordinate_matrix.hpp:189
viennacl::tools::const_sparse_matrix_adapter
Adapts a constant sparse matrix type made up from std::vector > to basic ub...
Definition: adapter.hpp:183
viennacl::coordinate_matrix::clear
void clear()
Resets all entries in the matrix back to zero without changing the matrix size. Resets the sparsity p...
Definition: coordinate_matrix.hpp:342
viennacl::vcl_size_t
std::size_t vcl_size_t
Definition: forwards.h:75
viennacl::vector
Definition: forwards.h:266
viennacl::coordinate_matrix::handle3
const handle_type & handle3() const
Returns the OpenCL handle to the group start index array.
Definition: coordinate_matrix.hpp:370
viennacl::context::memory_type
viennacl::memory_types memory_type() const
Definition: context.hpp:76
viennacl::coordinate_matrix::copy
friend void copy(const CPUMatrixT &cpu_matrix, coordinate_matrix< NumericT2, AlignmentV2 > &gpu_matrix)
viennacl::backend::mem_handle::switch_active_handle_id
void switch_active_handle_id(memory_types new_id)
Switches the currently active handle. If no support for that backend is provided, an exception is thr...
Definition: mem_handle.hpp:121
viennacl::backend::memory_copy
void memory_copy(mem_handle const &src_buffer, mem_handle &dst_buffer, vcl_size_t src_offset, vcl_size_t dst_offset, vcl_size_t bytes_to_copy)
Copies 'bytes_to_copy' bytes from address 'src_buffer + src_offset' to memory starting at address 'ds...
Definition: memory.hpp:140
viennacl::coordinate_matrix::reserve
void reserve(vcl_size_t new_nonzeros)
Allocate memory for the supplied number of nonzeros in the matrix. Old values are preserved...
Definition: coordinate_matrix.hpp:270
viennacl::traits::context
viennacl::context context(T const &t)
Returns an ID for the currently active memory domain of an object.
Definition: context.hpp:40
viennacl::coordinate_matrix::handle
const handle_type & handle() const
Returns the OpenCL handle to the matrix entry array.
Definition: coordinate_matrix.hpp:368
vector.hpp
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
viennacl::copy
void copy(std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) ...
Definition: circulant_matrix.hpp:150
viennacl::backend::typesafe_host_array::set
void set(vcl_size_t index, U value)
Definition: util.hpp:115
viennacl::coordinate_matrix::groups
vcl_size_t groups() const
Definition: coordinate_matrix.hpp:372
viennacl::backend::mem_handle
Main abstraction class for multiple memory domains. Represents a buffer in either main RAM...
Definition: mem_handle.hpp:89
viennacl::backend::mem_handle::raw_size
vcl_size_t raw_size() const
Returns the number of bytes of the currently active buffer.
Definition: mem_handle.hpp:230
viennacl::tools::sparse_matrix_adapter
Adapts a non-const sparse matrix type made up from std::vector > to basic u...
Definition: adapter.hpp:357
viennacl::coordinate_matrix::coordinate_matrix
coordinate_matrix(vcl_size_t rows, vcl_size_t cols, viennacl::context ctx)
Construction of a coordinate matrix with the supplied number of rows and columns in the supplied cont...
Definition: coordinate_matrix.hpp:251
viennacl::backend::memory_create
void memory_create(mem_handle &handle, vcl_size_t size_in_bytes, viennacl::context const &ctx, const void *host_ptr=NULL)
Creates an array of the specified size. If the second argument is provided, the buffer is initialized...
Definition: memory.hpp:87
viennacl::linalg::prod_impl
void prod_impl(const matrix_base< NumericT > &mat, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
Carries out matrix-vector multiplication.
Definition: matrix_operations.hpp:438
viennacl::traits::handle
viennacl::backend::mem_handle & handle(T &obj)
Returns the generic memory handle of an object. Non-const version.
Definition: handle.hpp:41
viennacl::coordinate_matrix::size1
vcl_size_t size1() const
Returns the number of rows.
Definition: coordinate_matrix.hpp:357
op_assign
Definition: self_assign.cpp:132
viennacl::backend::memory_shallow_copy
void memory_shallow_copy(mem_handle const &src_buffer, mem_handle &dst_buffer)
A 'shallow' copy operation from an initialized buffer to an uninitialized buffer. The uninitialized b...
Definition: memory.hpp:177
viennacl::coordinate_matrix
A sparse square matrix, where entries are stored as triplets (i,j, val), where i and j are the row an...
Definition: coordinate_matrix.hpp:186