void prod_impl(const viennacl::compressed_matrix<TYPE, ALIGNMENT> & mat, const viennacl::vector<TYPE, VECTOR_ALIGNMENT> & vec, viennacl::vector<TYPE, VECTOR_ALIGNMENT> & result, size_t NUM_THREADS = 0) { assert(mat.size1() == result.size()); assert(mat.size2() == vec.size()); viennacl::ocl::kernel & k = viennacl::ocl::get_kernel(viennacl::linalg::kernels::compressed_matrix<TYPE, ALIGNMENT>::program_name(), "vec_mul"); viennacl::ocl::enqueue(k(mat.handle1(), mat.handle2(), mat.handle(), vec, result, static_cast<cl_uint>(mat.size1()))); }
void copy(viennashe::math::sparse_matrix<NumericT> const & assembled_matrix, viennacl::compressed_matrix<NumericT> & vcl_matrix) { std::size_t nonzeros = assembled_matrix.nnz(); viennacl::backend::typesafe_host_array<unsigned int> row_buffer(vcl_matrix.handle1(), assembled_matrix.size1() + 1); viennacl::backend::typesafe_host_array<unsigned int> col_buffer(vcl_matrix.handle2(), nonzeros); std::vector<NumericT> elements(nonzeros); std::size_t data_index = 0; for (std::size_t i = 0; i != assembled_matrix.size1(); ++i) { typedef typename viennashe::math::sparse_matrix<NumericT>::const_iterator2 AlongRowIterator; typedef typename viennashe::math::sparse_matrix<NumericT>::row_type RowType; row_buffer.set(i, data_index); RowType const & row_i = assembled_matrix.row(i); for (AlongRowIterator col_it = row_i.begin(); col_it != row_i.end(); ++col_it) { col_buffer.set(data_index, col_it->first); elements[data_index] = col_it->second; ++data_index; } } row_buffer.set(assembled_matrix.size1(), data_index); vcl_matrix.set(row_buffer.get(), col_buffer.get(), &elements[0], assembled_matrix.size1(), assembled_matrix.size2(), nonzeros); }
NumericT setup_w(viennacl::compressed_matrix<NumericT> const & A, SizeT row, SparseVectorT & w) { assert( (A.handle1().get_active_handle_id() == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ILUT") ); assert( (A.handle2().get_active_handle_id() == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ILUT") ); assert( (A.handle().get_active_handle_id() == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ILUT") ); NumericT const * elements = viennacl::linalg::host_based::detail::extract_raw_pointer<NumericT>(A.handle()); unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.handle1()); unsigned int const * col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.handle2()); SizeT row_i_begin = static_cast<SizeT>(row_buffer[row]); SizeT row_i_end = static_cast<SizeT>(row_buffer[row+1]); NumericT row_norm = 0; for (SizeT buf_index_i = row_i_begin; buf_index_i < row_i_end; ++buf_index_i) //Note: We do not assume that the column indices within a row are sorted { NumericT entry = elements[buf_index_i]; w[col_buffer[buf_index_i]] = entry; row_norm += entry * entry; } return std::sqrt(row_norm); }
static size_t get(const ::viennacl::compressed_matrix<V> &A) { return A.nnz(); }
static size_t size(const viennacl::compressed_matrix<ScalarType, Amat> & lhs, const viennacl::vector<ScalarType, A> & rhs) { return lhs.size1(); }
void precondition(viennacl::compressed_matrix<ScalarType> & A, ichol0_tag const & /* tag */) { assert( (viennacl::memory_domain(A) == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ICHOL0") ); ScalarType * elements = viennacl::linalg::host_based::detail::extract_raw_pointer<ScalarType>(A.handle()); unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.handle1()); unsigned int const * col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.handle2()); //std::cout << A.size1() << std::endl; for (std::size_t i=0; i<A.size1(); ++i) { unsigned int row_i_begin = row_buffer[i]; unsigned int row_i_end = row_buffer[i+1]; // get a_ii: ScalarType a_ii = 0; for (unsigned int buf_index_aii = row_i_begin; buf_index_aii < row_i_end; ++buf_index_aii) { if (col_buffer[buf_index_aii] == i) { a_ii = std::sqrt(elements[buf_index_aii]); elements[buf_index_aii] = a_ii; break; } } // Now scale column/row i, i.e. A(k, i) /= A(i, i) for (unsigned int buf_index_aii = row_i_begin; buf_index_aii < row_i_end; ++buf_index_aii) { if (col_buffer[buf_index_aii] > i) elements[buf_index_aii] /= a_ii; } // Now compute A(k, j) -= A(k, i) * A(j, i) for all nonzero k, j in column i: for (unsigned int buf_index_j = row_i_begin; buf_index_j < row_i_end; ++buf_index_j) { unsigned int j = col_buffer[buf_index_j]; if (j <= i) continue; ScalarType a_ji = elements[buf_index_j]; for (unsigned int buf_index_k = row_i_begin; buf_index_k < row_i_end; ++buf_index_k) { unsigned int k = col_buffer[buf_index_k]; if (k < j) continue; ScalarType a_ki = elements[buf_index_k]; //Now check whether A(k, j) is in nonzero pattern: unsigned int row_j_begin = row_buffer[j]; unsigned int row_j_end = row_buffer[j+1]; for (unsigned int buf_index_kj = row_j_begin; buf_index_kj < row_j_end; ++buf_index_kj) { if (col_buffer[buf_index_kj] == k) { elements[buf_index_kj] -= a_ki * a_ji; break; } } } } } }
void precondition(viennacl::compressed_matrix<ScalarType> & A, ilu0_tag const & /* tag */) { assert( (A.handle1().get_active_handle_id() == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ILU0") ); assert( (A.handle2().get_active_handle_id() == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ILU0") ); assert( (A.handle().get_active_handle_id() == viennacl::MAIN_MEMORY) && bool("System matrix must reside in main memory for ILU0") ); ScalarType * elements = viennacl::linalg::host_based::detail::extract_raw_pointer<ScalarType>(A.handle()); unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.handle1()); unsigned int const * col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.handle2()); // Note: Line numbers in the following refer to the algorithm in Saad's book for (std::size_t i=1; i<A.size1(); ++i) // Line 1 { unsigned int row_i_begin = row_buffer[i]; unsigned int row_i_end = row_buffer[i+1]; for (unsigned int buf_index_k = row_i_begin; buf_index_k < row_i_end; ++buf_index_k) //Note: We do not assume that the column indices within a row are sorted { unsigned int k = col_buffer[buf_index_k]; if (k >= i) continue; //Note: We do not assume that the column indices within a row are sorted unsigned int row_k_begin = row_buffer[k]; unsigned int row_k_end = row_buffer[k+1]; // get a_kk: ScalarType a_kk = 0; for (unsigned int buf_index_akk = row_k_begin; buf_index_akk < row_k_end; ++buf_index_akk) { if (col_buffer[buf_index_akk] == k) { a_kk = elements[buf_index_akk]; break; } } ScalarType & a_ik = elements[buf_index_k]; a_ik /= a_kk; //Line 3 for (unsigned int buf_index_j = row_i_begin; buf_index_j < row_i_end; ++buf_index_j) //Note: We do not assume that the column indices within a row are sorted { unsigned int j = col_buffer[buf_index_j]; if (j <= k) continue; // determine a_kj: ScalarType a_kj = 0; for (unsigned int buf_index_akj = row_k_begin; buf_index_akj < row_k_end; ++buf_index_akj) { if (col_buffer[buf_index_akj] == j) { a_kk = elements[buf_index_akj]; break; } } //a_ij -= a_ik * a_kj elements[buf_index_j] -= a_ik * a_kj; //Line 5 } } } }