1 #ifndef VIENNACL_LINALG_DETAIL_BLOCK_ILU_HPP_
2 #define VIENNACL_LINALG_DETAIL_BLOCK_ILU_HPP_
42 template<
typename VectorT,
typename NumericT,
typename SizeT = vcl_
size_t>
49 ) : vec_(v), start_(start_index), size_(vec_size) {}
53 assert(index < size_ &&
bool(
"Index out of bounds!"));
54 return vec_[start_ + index];
59 assert(index < size_ &&
bool(
"Index out of bounds!"));
60 return vec_[start_ + index];
63 SizeT
size()
const {
return size_; }
78 template<
typename NumericT>
89 NumericT
const * A_elements = viennacl::linalg::host_based::detail::extract_raw_pointer<NumericT>(A.
handle());
90 unsigned int const * A_row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.
handle1());
91 unsigned int const * A_col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(A.
handle2());
93 NumericT * output_elements = viennacl::linalg::host_based::detail::extract_raw_pointer<NumericT>(diagonal_block_A.
handle());
94 unsigned int * output_row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(diagonal_block_A.
handle1());
95 unsigned int * output_col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(diagonal_block_A.
handle2());
100 unsigned int buffer_col_start = A_row_buffer[
row];
101 unsigned int buffer_col_end = A_row_buffer[
row+1];
103 output_row_buffer[
row - start_index] =
static_cast<unsigned int>(output_counter);
105 for (
unsigned int buf_index = buffer_col_start; buf_index < buffer_col_end; ++buf_index)
107 unsigned int col = A_col_buffer[buf_index];
108 if (col < start_index)
111 if (col >= static_cast<unsigned int>(stop_index))
114 output_col_buffer[output_counter] =
static_cast<unsigned int>(col - start_index);
115 output_elements[output_counter] = A_elements[buf_index];
118 output_row_buffer[
row - start_index + 1] =
static_cast<unsigned int>(output_counter);
131 template<
typename MatrixT,
typename ILUTag>
134 typedef typename MatrixT::value_type ScalarType;
143 ) : tag_(tag), LU_blocks(num_blocks)
146 block_indices_.resize(num_blocks);
149 vcl_size_t start_index = ( i * mat.size1()) / num_blocks;
150 vcl_size_t stop_index = ((i+1) * mat.size1()) / num_blocks;
152 block_indices_[i] = std::pair<vcl_size_t, vcl_size_t>(start_index, stop_index);
163 index_vector_type
const & block_boundaries
164 ) : tag_(tag), block_indices_(block_boundaries), LU_blocks(block_boundaries.
size())
173 template<
typename VectorT>
176 for (
vcl_size_t i=0; i<block_indices_.size(); ++i)
180 unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(LU_blocks[i].handle1());
181 unsigned int const * col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(LU_blocks[i].handle2());
182 ScalarType
const * elements = viennacl::linalg::host_based::detail::extract_raw_pointer<ScalarType>(LU_blocks[i].handle());
184 viennacl::linalg::host_based::detail::csr_inplace_solve<ScalarType>(row_buffer, col_buffer, elements, vec_range, LU_blocks[i].size2(),
unit_lower_tag());
185 viennacl::linalg::host_based::detail::csr_inplace_solve<ScalarType>(row_buffer, col_buffer, elements, vec_range, LU_blocks[i].size2(),
upper_tag());
190 void init(MatrixT
const & A)
197 unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(mat.handle1());
199 #ifdef VIENNACL_WITH_OPENMP
200 #pragma omp parallel for
202 for (
long i2=0; i2<static_cast<long>(block_indices_.size()); ++i2)
206 vcl_size_t block_size = block_indices_[i].second - block_indices_[i].first;
207 vcl_size_t block_nnz = row_buffer[block_indices_[i].second] - row_buffer[block_indices_[i].first];
214 preconditioner_dispatch(mat_block, LU_blocks[i], tag_);
231 std::vector< std::map<unsigned int, ScalarType> > temp(mat_block.
size1());
239 index_vector_type block_indices_;
240 std::vector< viennacl::compressed_matrix<ScalarType> > LU_blocks;
251 template<
typename NumericT,
unsigned int AlignmentV,
typename ILUTagT>
264 block_indices_(num_blocks),
265 gpu_block_indices_(),
269 LU_blocks_(num_blocks)
272 block_indices_.resize(num_blocks);
278 block_indices_[i] = std::pair<vcl_size_t, vcl_size_t>(start_index, stop_index);
289 index_vector_type
const & block_boundaries
291 block_indices_(block_boundaries),
292 gpu_block_indices_(),
296 LU_blocks_(block_boundaries.
size())
321 void init(MatrixType
const & A)
328 unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(mat.handle1());
330 #ifdef VIENNACL_WITH_OPENMP
331 #pragma omp parallel for
333 for (
long i=0; i<static_cast<long>(block_indices_.size()); ++i)
336 vcl_size_t block_size = block_indices_[
static_cast<vcl_size_t>(i)].second - block_indices_[static_cast<vcl_size_t>(i)].first;
337 vcl_size_t block_nnz = row_buffer[block_indices_[
static_cast<vcl_size_t>(i)].second] - row_buffer[block_indices_[static_cast<vcl_size_t>(i)].first];
340 detail::extract_block_matrix(mat, mat_block, block_indices_[static_cast<vcl_size_t>(i)].first, block_indices_[static_cast<vcl_size_t>(i)].second);
344 preconditioner_dispatch(mat_block, LU_blocks_[static_cast<vcl_size_t>(i)], tag_);
356 for (
vcl_size_t i=0; i<block_indices_.size(); ++i)
358 block_indices_uint.
set(2*i, block_indices_[i].first);
359 block_indices_uint.set(2*i + 1, block_indices_[i].second);
364 blocks_to_device(mat.size1());
371 std::vector< std::map<unsigned int, NumericT> > L_transposed(matrix_size);
372 std::vector< std::map<unsigned int, NumericT> > U_transposed(matrix_size);
373 std::vector<NumericT> entries_D(matrix_size);
378 for (
vcl_size_t block_index = 0; block_index < LU_blocks_.size(); ++block_index)
380 MatrixType
const & current_block = LU_blocks_[block_index];
382 unsigned int const * row_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(current_block.handle1());
383 unsigned int const * col_buffer = viennacl::linalg::host_based::detail::extract_raw_pointer<unsigned int>(current_block.handle2());
384 NumericT
const * elements = viennacl::linalg::host_based::detail::extract_raw_pointer<NumericT>(current_block.handle());
386 vcl_size_t block_start = block_indices_[block_index].first;
391 unsigned int buffer_col_start = row_buffer[
row];
392 unsigned int buffer_col_end = row_buffer[
row+1];
394 for (
unsigned int buf_index = buffer_col_start; buf_index < buffer_col_end; ++buf_index)
396 unsigned int col = col_buffer[buf_index];
399 L_transposed[col + block_start][
static_cast<unsigned int>(
row + block_start)] = elements[buf_index];
401 entries_D[
row + block_start] = elements[buf_index];
403 U_transposed[col + block_start][
static_cast<unsigned int>(
row + block_start)] = elements[buf_index];
411 tools::const_sparse_matrix_adapter<NumericT, unsigned int> adapted_L_transposed(L_transposed, matrix_size, matrix_size);
412 tools::const_sparse_matrix_adapter<NumericT, unsigned int> adapted_U_transposed(U_transposed, matrix_size, matrix_size);
430 std::vector< std::map<unsigned int, NumericT> > temp(mat_block.
size1());
438 ILUTagT
const & tag_;
439 index_vector_type block_indices_;
445 std::vector<MatrixType> LU_blocks_;
Helper class implementing an array on the host. Default case: No conversion necessary.
const vcl_size_t & size1() const
Returns the number of rows.
NumericT & operator[](SizeT index)
vcl_size_t size1(MatrixType const &mat)
Generic routine for obtaining the number of rows of a matrix (ViennaCL, uBLAS, etc.)
A tag for incomplete LU factorization with static pattern (ILU0)
void precondition(viennacl::compressed_matrix< NumericT > &A, ilu0_tag const &)
Implementation of a ILU-preconditioner with static pattern. Optimized version for CSR matrices...
This file provides the forward declarations for the main types used within ViennaCL.
Implementations of incomplete factorization preconditioners with static nonzero pattern.
A block ILU preconditioner class, can be supplied to solve()-routines.
result_of::size_type< MatrixType >::type size2(MatrixType const &mat)
Generic routine for obtaining the number of columns of a matrix (ViennaCL, uBLAS, etc...
const handle_type & handle() const
Returns the OpenCL handle to the matrix entry array.
const handle_type & handle1() const
Returns the OpenCL handle to the row index array.
void extract_block_matrix(viennacl::compressed_matrix< NumericT > const &A, viennacl::compressed_matrix< NumericT > &diagonal_block_A, vcl_size_t start_index, vcl_size_t stop_index)
Extracts a diagonal block from a larger system matrix.
Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also su...
Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.
std::vector< std::pair< vcl_size_t, vcl_size_t > > index_vector_type
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
A tag class representing an upper triangular matrix.
A tag for incomplete LU factorization with threshold (ILUT)
const handle_type & handle2() const
Returns the OpenCL handle to the column index array.
NumericT & operator()(SizeT index)
block_ilu_precond(MatrixT const &mat, ILUTag const &tag, vcl_size_t num_blocks=8)
ilu_vector_range(VectorT &v, SizeT start_index, SizeT vec_size)
std::vector< std::pair< vcl_size_t, vcl_size_t > > index_vector_type
void trans(const matrix_expression< const matrix_base< NumericT, SizeT, DistanceT >, const matrix_base< NumericT, SizeT, DistanceT >, op_trans > &proxy, matrix_base< NumericT > &temp_trans)
void apply(VectorT &vec) const
block_ilu_precond(MatrixType const &mat, ILUTagT const &tag, index_vector_type const &block_boundaries)
vector_expression< const matrix_base< NumericT, F >, const unsigned int, op_row > row(const matrix_base< NumericT, F > &A, unsigned int i)
Implementations of an incomplete factorization preconditioner with threshold (ILUT) ...
viennacl::context context(T const &t)
Returns an ID for the currently active memory domain of an object.
block_ilu_precond(MatrixType const &mat, ILUTagT const &tag, vcl_size_t num_blocks=8)
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) ...
void set(vcl_size_t index, U value)
A tag class representing a lower triangular matrix with unit diagonal.
Main abstraction class for multiple memory domains. Represents a buffer in either main RAM...
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...
Helper range class for representing a subvector of a larger buffer.
Common routines used within ILU-type preconditioners.
void apply(vector< NumericT > &vec) const
block_ilu_precond(MatrixT const &mat, ILUTag const &tag, index_vector_type const &block_boundaries)
memory_types get_active_handle_id() const
Returns an ID for the currently active memory buffer. Other memory buffers might contain old or no da...
viennacl::enable_if< viennacl::is_any_sparse_matrix< SparseMatrixType >::value >::type block_inplace_solve(const matrix_expression< const SparseMatrixType, const SparseMatrixType, op_trans > &mat, viennacl::backend::mem_handle const &block_index_array, vcl_size_t num_blocks, viennacl::vector_base< ScalarType > const &mat_diagonal, viennacl::vector_base< ScalarType > &vec, SOLVERTAG tag)
void switch_memory_context(T &obj, viennacl::context new_ctx)
Generic convenience routine for migrating data of an object to a new memory domain.