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())));
}
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);
}
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
}
}
}
}