1 #ifndef VIENNACL_COORDINATE_MATRIX_HPP_
2 #define VIENNACL_COORDINATE_MATRIX_HPP_
46 template <
typename CPU_MATRIX,
typename SCALARTYPE,
unsigned int ALIGNMENT>
47 void copy(
const CPU_MATRIX & cpu_matrix,
56 if ( cpu_matrix.size1() > 0 && cpu_matrix.size2() > 0 )
59 for (
typename CPU_MATRIX::const_iterator1 row_it = cpu_matrix.begin1();
60 row_it != cpu_matrix.end1();
63 for (
typename CPU_MATRIX::const_iterator2 col_it = row_it.begin();
64 col_it != row_it.end();
72 gpu_matrix.nonzeros_ = num_entries;
73 gpu_matrix.rows_ = cpu_matrix.size1();
74 gpu_matrix.cols_ = cpu_matrix.size2();
78 std::vector<SCALARTYPE> elements(gpu_matrix.
internal_nnz());
83 group_boundaries.
set(0, 0);
84 for (
typename CPU_MATRIX::const_iterator1 row_it = cpu_matrix.begin1();
85 row_it != cpu_matrix.end1();
88 for (
typename CPU_MATRIX::const_iterator2 col_it = row_it.begin();
89 col_it != row_it.end();
92 coord_buffer.set(2*data_index, col_it.index1());
93 coord_buffer.set(2*data_index + 1, col_it.index2());
94 elements[data_index] = *col_it;
98 while (data_index > (current_fraction + 1) /
static_cast<double>(group_num) * num_entries)
99 group_boundaries.
set(++current_fraction, data_index);
103 group_boundaries.set(group_num, data_index);
121 template <
typename SCALARTYPE,
unsigned int ALIGNMENT>
122 void copy(
const std::vector< std::map<unsigned int, SCALARTYPE> > & cpu_matrix,
138 template <
typename CPU_MATRIX,
typename SCALARTYPE,
unsigned int ALIGNMENT>
140 CPU_MATRIX & cpu_matrix )
145 if ( gpu_matrix.
size1() > 0 && gpu_matrix.
size2() > 0 )
149 std::vector<SCALARTYPE> elements(gpu_matrix.
nnz());
157 for (
vcl_size_t index = 0; index < gpu_matrix.
nnz(); ++index)
158 cpu_matrix(coord_buffer[2*index], coord_buffer[2*index+1]) = elements[index];
168 template <
typename SCALARTYPE,
unsigned int ALIGNMENT>
170 std::vector< std::map<unsigned int, SCALARTYPE> > & cpu_matrix)
173 copy(gpu_matrix, temp);
185 template<
class SCALARTYPE,
unsigned int ALIGNMENT >
202 #ifdef VIENNACL_WITH_OPENCL
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());
220 rows_(rows), cols_(cols), nonzeros_(nonzeros)
234 #ifdef VIENNACL_WITH_OPENCL
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());
252 : rows_(rows), cols_(cols), nonzeros_(0)
258 #ifdef VIENNACL_WITH_OPENCL
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());
272 if (new_nonzeros > nonzeros_)
274 handle_type coord_buffer_old;
275 handle_type elements_old;
279 vcl_size_t internal_new_nnz = viennacl::tools::align_to_multiple<vcl_size_t>(new_nonzeros, ALIGNMENT);
287 nonzeros_ = new_nonzeros;
299 assert (new_size1 > 0 && new_size2 > 0);
301 if (new_size1 < rows_ || new_size2 < cols_)
303 std::vector<std::map<unsigned int, SCALARTYPE> > stl_sparse_matrix;
305 stl_sparse_matrix.resize(rows_);
307 if (preserve && rows_ > 0)
310 stl_sparse_matrix.resize(new_size1);
313 if (new_size2 < cols_ && rows_ > 0)
315 for (
vcl_size_t i=0; i<stl_sparse_matrix.size(); ++i)
317 std::list<unsigned int> to_delete;
318 for (
typename std::map<unsigned int, SCALARTYPE>::iterator it = stl_sparse_matrix[i].begin();
319 it != stl_sparse_matrix[i].end();
322 if (it->first >= new_size2)
323 to_delete.push_back(it->first);
326 for (std::list<unsigned int>::iterator it = to_delete.begin(); it != to_delete.end(); ++it)
327 stl_sparse_matrix[i].erase(*it);
352 const handle_type &
handle12()
const {
return coord_buffer_; }
354 const handle_type &
handle()
const {
return elements_; }
356 const handle_type &
handle3()
const {
return group_boundaries_; }
360 #if defined(_MSC_VER) && _MSC_VER < 1500 //Visual Studio 2005 needs special treatment
361 template <
typename CPU_MATRIX>
364 template <
typename CPU_MATRIX,
typename SCALARTYPE2,
unsigned int ALIGNMENT2>
380 handle_type coord_buffer_;
381 handle_type elements_;
382 handle_type group_boundaries_;
397 template <
typename T,
unsigned int A>
398 struct op_executor<vector_base<T>, op_assign, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> >
400 static void apply(vector_base<T> & lhs, vector_expression<
const coordinate_matrix<T, A>,
const vector_base<T>, op_prod>
const & rhs)
414 template <
typename T,
unsigned int A>
415 struct op_executor<vector_base<T>, op_inplace_add, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> >
417 static void apply(vector_base<T> & lhs, vector_expression<
const coordinate_matrix<T, A>,
const vector_base<T>, op_prod>
const & rhs)
425 template <
typename T,
unsigned int A>
426 struct op_executor<vector_base<T>, op_inplace_sub, vector_expression<const coordinate_matrix<T, A>, const vector_base<T>, op_prod> >
428 static void apply(vector_base<T> & lhs, vector_expression<
const coordinate_matrix<T, A>,
const vector_base<T>, op_prod>
const & rhs)
438 template <
typename T,
unsigned int A,
typename LHS,
typename RHS,
typename OP>
439 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> >
441 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)
449 template <
typename T,
unsigned int A,
typename LHS,
typename RHS,
typename OP>
450 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> >
452 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)
462 template <
typename T,
unsigned int A,
typename LHS,
typename RHS,
typename OP>
463 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> >
465 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)
Helper class implementing an array on the host. Default case: No conversion necessary.
Definition: util.hpp:95
std::size_t vcl_size_t
Definition: forwards.h:58
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
friend void copy(const CPU_MATRIX &cpu_matrix, coordinate_matrix< SCALARTYPE2, ALIGNMENT2 > &gpu_matrix)
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Definition: forwards.h:172
vcl_size_t size1(MatrixType const &mat)
Generic routine for obtaining the number of rows of a matrix (ViennaCL, uBLAS, etc.)
Definition: size.hpp:216
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
vcl_size_t size2() const
Returns the number of columns.
Definition: coordinate_matrix.hpp:345
vcl_size_t size1() const
Returns the number of rows.
Definition: coordinate_matrix.hpp:343
This file provides the forward declarations for the main types used within ViennaCL.
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
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:245
void set(vcl_size_t index, U value)
Definition: util.hpp:145
vcl_size_t element_size(memory_types)
Definition: memory.hpp:299
const handle_type & handle() const
Returns the OpenCL handle to the matrix entry array.
Definition: coordinate_matrix.hpp:354
Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also su...
Definition: context.hpp:39
Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.
Definition: cpu_ram.hpp:29
const handle_type & handle3() const
Returns the OpenCL handle to the group start index array.
Definition: coordinate_matrix.hpp:356
coordinate_matrix(viennacl::context ctx)
Definition: coordinate_matrix.hpp:196
Definition: forwards.h:480
vcl_size_t groups() const
Definition: coordinate_matrix.hpp:358
Implementations of operations using sparse matrices.
const handle_type & handle12() const
Returns the OpenCL handle to the (row, column) index array.
Definition: coordinate_matrix.hpp:352
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
void copy(std::vector< SCALARTYPE > &cpu_vec, circulant_matrix< SCALARTYPE, ALIGNMENT > &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::memory_types memory_type() const
Definition: context.hpp:76
A vector class representing a linear memory sequence on the GPU. Inspired by boost::numeric::ublas::v...
Definition: forwards.h:208
coordinate_matrix()
Default construction of a coordinate matrix. No memory is allocated.
Definition: coordinate_matrix.hpp:194
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
vcl_size_t raw_size() const
Returns the number of bytes of the currently active buffer.
Definition: mem_handle.hpp:203
viennacl::context context(T const &t)
Returns an ID for the currently active memory domain of an object.
Definition: context.hpp:41
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
Main abstraction class for multiple memory domains. Represents a buffer in either main RAM...
Definition: mem_handle.hpp:62
vcl_size_t size_type
Definition: coordinate_matrix.hpp:191
void prod_impl(const matrix_base< NumericT, F > &mat, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
Carries out matrix-vector multiplication.
Definition: matrix_operations.hpp:350
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
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:94
viennacl::backend::mem_handle & handle(T &obj)
Returns the generic memory handle of an object. Non-const version.
Definition: handle.hpp:41
void resize(vcl_size_t new_size1, vcl_size_t new_size2, bool preserve=true)
Resize the matrix.
Definition: coordinate_matrix.hpp:297
vcl_size_t internal_nnz() const
Returns the number of internal nonzero entries.
Definition: coordinate_matrix.hpp:349
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::backend::mem_handle handle_type
Definition: coordinate_matrix.hpp:189
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
vcl_size_t nnz() const
Returns the number of nonzero entries.
Definition: coordinate_matrix.hpp:347
scalar< typename viennacl::tools::CHECK_SCALAR_TEMPLATE_ARGUMENT< SCALARTYPE >::ResultType > value_type
Definition: coordinate_matrix.hpp:190