magma_int_t
magma_zmLdiagadd(
magma_z_matrix *L,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix LL={Magma_CSR};
if( L->row[1]==1 ){ // lower triangular with unit diagonal
//printf("L lower triangular.\n");
LL.diagorder_type = Magma_UNITY;
CHECK( magma_zmconvert( *L, &LL, Magma_CSR, Magma_CSRL, queue ));
}
else if ( L->row[1]==0 ){ // strictly lower triangular
//printf("L strictly lower triangular.\n");
CHECK( magma_zmtransfer( *L, &LL, Magma_CPU, Magma_CPU, queue ));
magma_free_cpu( LL.col );
magma_free_cpu( LL.val );
LL.nnz = L->nnz+L->num_rows;
CHECK( magma_zmalloc_cpu( &LL.val, LL.nnz ));
CHECK( magma_index_malloc_cpu( &LL.col, LL.nnz ));
magma_int_t z=0;
for( magma_int_t i=0; i<L->num_rows; i++){
LL.row[i] = z;
for( magma_int_t j=L->row[i]; j<L->row[i+1]; j++){
LL.val[z] = L->val[j];
LL.col[z] = L->col[j];
z++;
}
// add unit diagonal
LL.val[z] = MAGMA_Z_MAKE(1.0, 0.0);
LL.col[z] = i;
z++;
}
LL.row[LL.num_rows] = z;
LL.nnz = z;
}
else {
printf("error: L neither lower nor strictly lower triangular!\n");
}
magma_zmfree( L, queue );
CHECK( magma_zmtransfer(LL, L, Magma_CPU, Magma_CPU, queue ));
cleanup:
if( info != 0 ){
magma_zmfree( L, queue );
}
magma_zmfree( &LL, queue );
return info;
}
magma_int_t
magma_zcsrget(
magma_z_matrix A,
magma_int_t *m,
magma_int_t *n,
magma_index_t **row,
magma_index_t **col,
magmaDoubleComplex **val,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix A_CPU={Magma_CSR}, A_CSR={Magma_CSR};
if ( A.memory_location == Magma_CPU && A.storage_type == Magma_CSR ) {
*m = A.num_rows;
*n = A.num_cols;
*val = A.val;
*col = A.col;
*row = A.row;
} else {
CHECK( magma_zmtransfer( A, &A_CPU, A.memory_location, Magma_CPU, queue ));
CHECK( magma_zmconvert( A_CPU, &A_CSR, A_CPU.storage_type, Magma_CSR, queue ));
CHECK( magma_zcsrget( A_CSR, m, n, row, col, val, queue ));
}
cleanup:
magma_zmfree( &A_CSR, queue );
magma_zmfree( &A_CPU, queue );
return info;
}
extern "C" magma_int_t
magma_zvtranspose(
magma_z_matrix x,
magma_z_matrix *y,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_int_t m = x.num_rows;
magma_int_t n = x.num_cols;
// set queue for old dense routines
magma_queue_t orig_queue=NULL;
magmablasGetKernelStream( &orig_queue );
magma_z_matrix x_d={Magma_CSR}, y_d={Magma_CSR};
if ( x.memory_location == Magma_DEV ) {
CHECK( magma_zvinit( y, Magma_DEV, x.num_rows,x.num_cols, MAGMA_Z_ZERO, queue ));
y->num_rows = x.num_rows;
y->num_cols = x.num_cols;
y->storage_type = x.storage_type;
if ( x.major == MagmaColMajor) {
y->major = MagmaRowMajor;
magmablas_ztranspose( m, n, x.val, m, y->val, n );
}
else {
y->major = MagmaColMajor;
magmablas_ztranspose( n, m, x.val, n, y->val, m );
}
} else {
CHECK( magma_zmtransfer( x, &x_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zvtranspose( x_d, &y_d, queue ));
CHECK( magma_zmtransfer( y_d, y, Magma_DEV, Magma_CPU, queue ));
}
cleanup:
if( info != 0 ){
magma_zmfree( y, queue );
}
magma_zmfree( &x_d, queue );
magma_zmfree( &y_d, queue );
magmablasSetKernelStream( orig_queue );
return info;
}
extern "C" magma_int_t
magma_zmcsrcompressor(
magma_z_matrix *A,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix B={Magma_CSR};
magma_z_matrix hA={Magma_CSR}, CSRA={Magma_CSR};
if ( A->memory_location == Magma_CPU && A->storage_type == Magma_CSR ) {
CHECK( magma_zmconvert( *A, &B, Magma_CSR, Magma_CSR, queue ));
magma_free_cpu( A->row );
magma_free_cpu( A->col );
magma_free_cpu( A->val );
CHECK( magma_z_csr_compressor(&B.val, &B.row, &B.col,
&A->val, &A->row, &A->col, &A->num_rows, queue ));
A->nnz = A->row[A->num_rows];
}
else {
magma_storage_t A_storage = A->storage_type;
magma_location_t A_location = A->memory_location;
CHECK( magma_zmtransfer( *A, &hA, A->memory_location, Magma_CPU, queue ));
CHECK( magma_zmconvert( hA, &CSRA, hA.storage_type, Magma_CSR, queue ));
CHECK( magma_zmcsrcompressor( &CSRA, queue ));
magma_zmfree( &hA, queue );
magma_zmfree( A, queue );
CHECK( magma_zmconvert( CSRA, &hA, Magma_CSR, A_storage, queue ));
CHECK( magma_zmtransfer( hA, A, Magma_CPU, A_location, queue ));
magma_zmfree( &hA, queue );
magma_zmfree( &CSRA, queue );
}
cleanup:
magma_zmfree( &hA, queue );
magma_zmfree( &CSRA, queue );
magma_zmfree( &B, queue );
return info;
}
extern "C" magma_int_t
magma_zmshrink(
magma_z_matrix A,
magma_z_matrix *B,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix hA={Magma_CSR}, hACSR={Magma_CSR}, hB={Magma_CSR}, hBCSR={Magma_CSR};
if( A.num_rows<=A.num_cols){
if( A.memory_location == Magma_CPU && A.storage_type == Magma_CSR ){
CHECK( magma_zmconvert( A, B, Magma_CSR, Magma_CSR, queue ));
for(magma_int_t i=0; i<A.nnz; i++){
if( B->col[i] >= A.num_rows ){
B->val[i] = MAGMA_Z_ZERO;
}
}
CHECK( magma_zmcsrcompressor( B, queue ) );
B->num_cols = B->num_rows;
} else {
CHECK( magma_zmtransfer( A, &hA, A.memory_location, Magma_CPU, queue ));
CHECK( magma_zmconvert( hA, &hACSR, A.storage_type, Magma_CSR, queue ));
CHECK( magma_zmshrink( hACSR, &hBCSR, queue ));
CHECK( magma_zmconvert( hBCSR, &hB, Magma_CSR, A.storage_type, queue ));
CHECK( magma_zmtransfer( hB, B, Magma_CPU, A.memory_location, queue ));
}
} else {
printf("%% error: A has too many rows: m > n.\n");
info = MAGMA_ERR_NOT_SUPPORTED;
goto cleanup;
}
cleanup:
magma_zmfree( &hA, queue );
magma_zmfree( &hB, queue );
magma_zmfree( &hACSR, queue );
magma_zmfree( &hBCSR, queue );
return info;
}
magma_int_t
magma_zsymbilu(
magma_z_matrix *A,
magma_int_t levels,
magma_z_matrix *L,
magma_z_matrix *U,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix A_copy={Magma_CSR}, B={Magma_CSR};
magma_z_matrix hA={Magma_CSR}, CSRCOOA={Magma_CSR};
if( A->memory_location == Magma_CPU && A->storage_type == Magma_CSR ){
CHECK( magma_zmtransfer( *A, &A_copy, Magma_CPU, Magma_CPU, queue ));
CHECK( magma_zmtransfer( *A, &B, Magma_CPU, Magma_CPU, queue ));
// possibility to scale to unit diagonal
//magma_zmscale( &B, Magma_UNITDIAG );
CHECK( magma_zmconvert( B, L, Magma_CSR, Magma_CSR , queue));
CHECK( magma_zmconvert( B, U, Magma_CSR, Magma_CSR, queue ));
magma_int_t num_lnnz = (levels > 0 ) ? B.nnz/2*(2*levels+50) : B.nnz;
magma_int_t num_unnz = (levels > 0 ) ? B.nnz/2*(2*levels+50) : B.nnz;
magma_free_cpu( L->col );
magma_free_cpu( U->col );
CHECK( magma_index_malloc_cpu( &L->col, num_lnnz ));
CHECK( magma_index_malloc_cpu( &U->col, num_unnz ));
magma_zsymbolic_ilu( levels, A->num_rows, &num_lnnz, &num_unnz, B.row, B.col,
L->row, L->col, U->row, U->col );
L->nnz = num_lnnz;
U->nnz = num_unnz;
magma_free_cpu( L->val );
magma_free_cpu( U->val );
CHECK( magma_zmalloc_cpu( &L->val, L->nnz ));
CHECK( magma_zmalloc_cpu( &U->val, U->nnz ));
for( magma_int_t i=0; i<L->nnz; i++ )
L->val[i] = MAGMA_Z_MAKE( 0.0, 0.0 );
for( magma_int_t i=0; i<U->nnz; i++ )
U->val[i] = MAGMA_Z_MAKE( 0.0, 0.0 );
// take the original values (scaled) as initial guess for L
for(magma_int_t i=0; i<L->num_rows; i++){
for(magma_int_t j=B.row[i]; j<B.row[i+1]; j++){
magma_index_t lcol = B.col[j];
for(magma_int_t k=L->row[i]; k<L->row[i+1]; k++){
if( L->col[k] == lcol ){
L->val[k] = B.val[j];
}
}
}
}
// take the original values (scaled) as initial guess for U
for(magma_int_t i=0; i<U->num_rows; i++){
for(magma_int_t j=B.row[i]; j<B.row[i+1]; j++){
magma_index_t lcol = B.col[j];
for(magma_int_t k=U->row[i]; k<U->row[i+1]; k++){
if( U->col[k] == lcol ){
U->val[k] = B.val[j];
}
}
}
}
magma_zmfree( &B, queue );
// fill A with the new structure;
magma_free_cpu( A->col );
magma_free_cpu( A->val );
CHECK( magma_index_malloc_cpu( &A->col, L->nnz+U->nnz ));
CHECK( magma_zmalloc_cpu( &A->val, L->nnz+U->nnz ));
A->nnz = L->nnz+U->nnz;
magma_int_t z = 0;
for(magma_int_t i=0; i<A->num_rows; i++){
A->row[i] = z;
for(magma_int_t j=L->row[i]; j<L->row[i+1]; j++){
A->col[z] = L->col[j];
A->val[z] = L->val[j];
z++;
}
for(magma_int_t j=U->row[i]; j<U->row[i+1]; j++){
A->col[z] = U->col[j];
A->val[z] = U->val[j];
z++;
}
}
A->row[A->num_rows] = z;
// reset the values of A to the original entries
for(magma_int_t i=0; i<A->num_rows; i++){
for(magma_int_t j=A_copy.row[i]; j<A_copy.row[i+1]; j++){
magma_index_t lcol = A_copy.col[j];
for(magma_int_t k=A->row[i]; k<A->row[i+1]; k++){
if( A->col[k] == lcol ){
A->val[k] = A_copy.val[j];
}
}
}
}
}
else {
magma_storage_t A_storage = A->storage_type;
magma_location_t A_location = A->memory_location;
CHECK( magma_zmtransfer( *A, &hA, A->memory_location, Magma_CPU, queue ));
CHECK( magma_zmconvert( hA, &CSRCOOA, hA.storage_type, Magma_CSR, queue ));
CHECK( magma_zsymbilu( &CSRCOOA, levels, L, U, queue ));
magma_zmfree( &hA, queue );
magma_zmfree( A, queue );
CHECK( magma_zmconvert( CSRCOOA, &hA, Magma_CSR, A_storage, queue ));
CHECK( magma_zmtransfer( hA, A, Magma_CPU, A_location, queue ));
}
cleanup:
if( info != 0 ){
magma_zmfree( L, queue );
magma_zmfree( U, queue );
}
magma_zmfree( &A_copy, queue );
magma_zmfree( &B, queue );
magma_zmfree( &hA, queue );
magma_zmfree( &CSRCOOA, queue );
return info;
}
extern "C" magma_int_t
magma_zcumiccsetup(
magma_z_matrix A,
magma_z_preconditioner *precond,
magma_queue_t queue )
{
magma_int_t info = 0;
cusparseHandle_t cusparseHandle=NULL;
cusparseMatDescr_t descrA=NULL;
cusparseMatDescr_t descrL=NULL;
cusparseMatDescr_t descrU=NULL;
#if CUDA_VERSION >= 7000
csric02Info_t info_M=NULL;
void *pBuffer = NULL;
#endif
magma_z_matrix hA={Magma_CSR}, hACSR={Magma_CSR}, U={Magma_CSR};
CHECK( magma_zmtransfer( A, &hA, A.memory_location, Magma_CPU, queue ));
U.diagorder_type = Magma_VALUE;
CHECK( magma_zmconvert( hA, &hACSR, hA.storage_type, Magma_CSR, queue ));
// in case using fill-in
if( precond->levels > 0 ){
magma_z_matrix hAL={Magma_CSR}, hAUt={Magma_CSR};
CHECK( magma_zsymbilu( &hACSR, precond->levels, &hAL, &hAUt, queue ));
magma_zmfree(&hAL, queue);
magma_zmfree(&hAUt, queue);
}
CHECK( magma_zmconvert( hACSR, &U, Magma_CSR, Magma_CSRL, queue ));
magma_zmfree( &hACSR, queue );
CHECK( magma_zmtransfer(U, &(precond->M), Magma_CPU, Magma_DEV, queue ));
// CUSPARSE context //
CHECK_CUSPARSE( cusparseCreate( &cusparseHandle ));
CHECK_CUSPARSE( cusparseSetStream( cusparseHandle, queue->cuda_stream() ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrA ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &(precond->cuinfo) ));
// use kernel to manually check for zeros n the diagonal
CHECK( magma_zdiagcheck( precond->M, queue ) );
#if CUDA_VERSION >= 7000
// this version has the bug fixed where a zero on the diagonal causes a crash
CHECK_CUSPARSE( cusparseCreateCsric02Info(&info_M) );
CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_GENERAL ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO ));
int buffersize;
int structural_zero;
int numerical_zero;
CHECK_CUSPARSE(
cusparseZcsric02_bufferSize( cusparseHandle,
precond->M.num_rows, precond->M.nnz, descrA,
precond->M.dval, precond->M.drow, precond->M.dcol,
info_M,
&buffersize ) );
CHECK( magma_malloc((void**)&pBuffer, buffersize) );
CHECK_CUSPARSE( cusparseZcsric02_analysis( cusparseHandle,
precond->M.num_rows, precond->M.nnz, descrA,
precond->M.dval, precond->M.drow, precond->M.dcol,
info_M, CUSPARSE_SOLVE_POLICY_NO_LEVEL, pBuffer ));
CHECK_CUSPARSE( cusparseXcsric02_zeroPivot( cusparseHandle, info_M, &numerical_zero ) );
CHECK_CUSPARSE( cusparseXcsric02_zeroPivot( cusparseHandle, info_M, &structural_zero ) );
CHECK_CUSPARSE(
cusparseZcsric02( cusparseHandle,
precond->M.num_rows, precond->M.nnz, descrA,
precond->M.dval, precond->M.drow, precond->M.dcol,
info_M, CUSPARSE_SOLVE_POLICY_NO_LEVEL, pBuffer) );
#else
// this version contains the bug but is needed for backward compability
CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_SYMMETRIC ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrA, CUSPARSE_DIAG_TYPE_NON_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrA, CUSPARSE_FILL_MODE_LOWER ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_NON_TRANSPOSE,
precond->M.num_rows, precond->M.nnz, descrA,
precond->M.dval, precond->M.drow, precond->M.dcol,
precond->cuinfo ));
CHECK_CUSPARSE( cusparseZcsric0( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE,
precond->M.num_rows, descrA,
precond->M.dval,
precond->M.drow,
precond->M.dcol,
precond->cuinfo ));
#endif
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrL ));
CHECK_CUSPARSE( cusparseSetMatType( descrL, CUSPARSE_MATRIX_TYPE_TRIANGULAR ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrL, CUSPARSE_DIAG_TYPE_NON_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrL, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrL, CUSPARSE_FILL_MODE_LOWER ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoL ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows,
precond->M.nnz, descrL,
precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoL ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrU ));
CHECK_CUSPARSE( cusparseSetMatType( descrU, CUSPARSE_MATRIX_TYPE_TRIANGULAR ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrU, CUSPARSE_DIAG_TYPE_NON_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrU, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrU, CUSPARSE_FILL_MODE_LOWER ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoU ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_TRANSPOSE, precond->M.num_rows,
precond->M.nnz, descrU,
precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoU ));
if( precond->maxiter < 50 ){
//prepare for iterative solves
// copy the matrix to precond->L and (transposed) to precond->U
CHECK( magma_zmtransfer(precond->M, &(precond->L), Magma_DEV, Magma_DEV, queue ));
CHECK( magma_zmtranspose( precond->L, &(precond->U), queue ));
// extract the diagonal of L into precond->d
CHECK( magma_zjacobisetup_diagscal( precond->L, &precond->d, queue ));
CHECK( magma_zvinit( &precond->work1, Magma_DEV, hA.num_rows, 1, MAGMA_Z_ZERO, queue ));
// extract the diagonal of U into precond->d2
CHECK( magma_zjacobisetup_diagscal( precond->U, &precond->d2, queue ));
CHECK( magma_zvinit( &precond->work2, Magma_DEV, hA.num_rows, 1, MAGMA_Z_ZERO, queue ));
}
/*
// to enable also the block-asynchronous iteration for the triangular solves
CHECK( magma_zmtransfer( precond->M, &hA, Magma_DEV, Magma_CPU, queue ));
hA.storage_type = Magma_CSR;
magma_z_matrix hD, hR, hAt
CHECK( magma_zcsrsplit( 256, hA, &hD, &hR, queue ));
CHECK( magma_zmtransfer( hD, &precond->LD, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( hR, &precond->L, Magma_CPU, Magma_DEV, queue ));
magma_zmfree(&hD, queue );
magma_zmfree(&hR, queue );
CHECK( magma_z_cucsrtranspose( hA, &hAt, queue ));
CHECK( magma_zcsrsplit( 256, hAt, &hD, &hR, queue ));
CHECK( magma_zmtransfer( hD, &precond->UD, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( hR, &precond->U, Magma_CPU, Magma_DEV, queue ));
magma_zmfree(&hD, queue );
magma_zmfree(&hR, queue );
magma_zmfree(&hA, queue );
magma_zmfree(&hAt, queue );
*/
cleanup:
#if CUDA_VERSION >= 7000
magma_free( pBuffer );
cusparseDestroyCsric02Info( info_M );
#endif
cusparseDestroySolveAnalysisInfo( precond->cuinfo );
cusparseDestroyMatDescr( descrL );
cusparseDestroyMatDescr( descrU );
cusparseDestroyMatDescr( descrA );
cusparseDestroy( cusparseHandle );
magma_zmfree(&U, queue );
magma_zmfree(&hA, queue );
return info;
}
magma_int_t
magma_zinitguess(
magma_z_matrix A,
magma_z_matrix *L,
magma_z_matrix *U,
magma_queue_t queue )
{
magma_int_t info = 0;
magmaDoubleComplex one = MAGMA_Z_MAKE( 1.0, 0.0 );
magma_z_matrix hAL={Magma_CSR}, hAU={Magma_CSR}, dAL={Magma_CSR},
dAU={Magma_CSR}, dALU={Magma_CSR}, hALU={Magma_CSR}, hD={Magma_CSR},
dD={Magma_CSR}, dL={Magma_CSR}, hL={Magma_CSR};
magma_int_t i,j;
magma_int_t offdiags = 0;
magma_index_t *diag_offset;
magmaDoubleComplex *diag_vals=NULL;
// need only lower triangular
hAL.diagorder_type = Magma_VALUE;
CHECK( magma_zmconvert( A, &hAL, Magma_CSR, Magma_CSRL, queue ));
//magma_zmconvert( hAL, &hALCOO, Magma_CSR, Magma_CSRCOO );
// need only upper triangular
//magma_zmconvert( A, &hAU, Magma_CSR, Magma_CSRU );
CHECK( magma_z_cucsrtranspose( hAL, &hAU, queue ));
//magma_zmconvert( hAU, &hAUCOO, Magma_CSR, Magma_CSRCOO );
CHECK( magma_zmtransfer( hAL, &dAL, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_z_spmm( one, dAL, dAU, &dALU, queue ));
CHECK( magma_zmtransfer( dALU, &hALU, Magma_DEV, Magma_CPU, queue ));
magma_zmfree( &dAU, queue);
magma_zmfree( &dALU, queue);
CHECK( magma_zmalloc_cpu( &diag_vals, offdiags+1 ));
CHECK( magma_index_malloc_cpu( &diag_offset, offdiags+1 ));
diag_offset[0] = 0;
diag_vals[0] = MAGMA_Z_MAKE( 1.0, 0.0 );
CHECK( magma_zmgenerator( hALU.num_rows, offdiags, diag_offset, diag_vals, &hD, queue ));
magma_zmfree( &hALU, queue );
for(i=0; i<hALU.num_rows; i++){
for(j=hALU.row[i]; j<hALU.row[i+1]; j++){
if( hALU.col[j] == i ){
//printf("%d %d %d == %d -> %f -->", i, j, hALU.col[j], i, hALU.val[j]);
hD.val[i] = MAGMA_Z_MAKE(
1.0 / sqrt(fabs(MAGMA_Z_REAL(hALU.val[j]))) , 0.0 );
//printf("insert %f at %d\n", hD.val[i], i);
}
}
}
CHECK( magma_zmtransfer( hD, &dD, Magma_CPU, Magma_DEV, queue ));
magma_zmfree( &hD, queue);
CHECK( magma_z_spmm( one, dD, dAL, &dL, queue ));
magma_zmfree( &dAL, queue );
magma_zmfree( &dD, queue );
/*
// check for diagonal = 1
magma_z_matrix dLt={Magma_CSR}, dLL={Magma_CSR}, LL={Magma_CSR};
CHECK( magma_z_cucsrtranspose( dL, &dLt ));
CHECK( magma_zcuspmm( dL, dLt, &dLL ));
CHECK( magma_zmtransfer( dLL, &LL, Magma_DEV, Magma_CPU ));
//for(i=0; i < hALU.num_rows; i++) {
for(i=0; i < 100; i++) {
for(j=hALU.row[i]; j < hALU.row[i+1]; j++) {
if( hALU.col[j] == i ){
printf("%d %d -> %f -->", i, i, LL.val[j]);
}
}
}
*/
CHECK( magma_zmtransfer( dL, &hL, Magma_DEV, Magma_CPU, queue ));
CHECK( magma_zmconvert( hL, L, Magma_CSR, Magma_CSRCOO, queue ));
cleanup:
if( info !=0 ){
magma_zmfree( L, queue );
magma_zmfree( U, queue );
}
magma_zmfree( &dAU, queue);
magma_zmfree( &dALU, queue);
magma_zmfree( &dL, queue );
magma_zmfree( &hL, queue );
magma_zmfree( &dAL, queue );
magma_zmfree( &dD, queue );
magma_zmfree( &hD, queue);
magma_zmfree( &hALU, queue );
return info;
}
/* ////////////////////////////////////////////////////////////////////////////
-- testing csr matrix add
*/
int main( int argc, char** argv )
{
magma_int_t info = 0;
TESTING_INIT();
magma_queue_t queue=NULL;
magma_queue_create( &queue );
real_Double_t res;
magma_z_matrix A={Magma_CSR}, B={Magma_CSR}, B2={Magma_CSR},
A_d={Magma_CSR}, B_d={Magma_CSR}, C_d={Magma_CSR};
magmaDoubleComplex one = MAGMA_Z_MAKE(1.0, 0.0);
magmaDoubleComplex mone = MAGMA_Z_MAKE(-1.0, 0.0);
magma_int_t i=1;
if ( strcmp("LAPLACE2D", argv[i]) == 0 && i+1 < argc ) { // Laplace test
i++;
magma_int_t laplace_size = atoi( argv[i] );
CHECK( magma_zm_5stencil( laplace_size, &A, queue ));
} else { // file-matrix test
CHECK( magma_z_csr_mtx( &A, argv[i], queue ));
}
printf("%% matrix info: %d-by-%d with %d nonzeros\n",
int(A.num_rows), int(A.num_cols), int(A.nnz) );
i++;
if ( strcmp("LAPLACE2D", argv[i]) == 0 && i+1 < argc ) { // Laplace test
i++;
magma_int_t laplace_size = atoi( argv[i] );
CHECK( magma_zm_5stencil( laplace_size, &B, queue ));
} else { // file-matrix test
CHECK( magma_z_csr_mtx( &B, argv[i], queue ));
}
printf("%% matrix info: %d-by-%d with %d nonzeros\n",
int(B.num_rows), int(B.num_cols), int(B.nnz) );
CHECK( magma_zmtransfer( A, &A_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( B, &B_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zcuspaxpy( &one, A_d, &one, B_d, &C_d, queue ));
magma_zmfree(&B_d, queue );
CHECK( magma_zcuspaxpy( &mone, A_d, &one, C_d, &B_d, queue ));
CHECK( magma_zmtransfer( B_d, &B2, Magma_DEV, Magma_CPU, queue ));
magma_zmfree(&A_d, queue );
magma_zmfree(&B_d, queue );
magma_zmfree(&C_d, queue );
// check difference
CHECK( magma_zmdiff( B, B2, &res, queue ));
printf("%% ||A-B||_F = %8.2e\n", res);
if ( res < .000001 )
printf("%% tester matrix add: ok\n");
else
printf("%% tester matrix add: failed\n");
magma_zmfree(&A, queue );
magma_zmfree(&B, queue );
magma_zmfree(&B2, queue );
cleanup:
magma_zmfree(&A_d, queue );
magma_zmfree(&B_d, queue );
magma_zmfree(&C_d, queue );
magma_zmfree(&A, queue );
magma_zmfree(&B, queue );
magma_zmfree(&B2, queue );
magma_queue_destroy( queue );
TESTING_FINALIZE();
return info;
}
magma_int_t
magma_zilures(
magma_z_matrix A,
magma_z_matrix L,
magma_z_matrix U,
magma_z_matrix *LU,
real_Double_t *res,
real_Double_t *nonlinres,
magma_queue_t queue )
{
magma_int_t info = 0;
magmaDoubleComplex tmp;
real_Double_t tmp2;
magma_int_t i, j, k;
magmaDoubleComplex one = MAGMA_Z_MAKE( 1.0, 0.0 );
magma_z_matrix LL={Magma_CSR}, L_d={Magma_CSR}, U_d={Magma_CSR}, LU_d={Magma_CSR};
if( L.row[1]==1 ){ // lower triangular with unit diagonal
//printf("L lower triangular.\n");
LL.diagorder_type = Magma_UNITY;
CHECK( magma_zmconvert( L, &LL, Magma_CSR, Magma_CSRL, queue ));
}
else if ( L.row[1]==0 ){ // strictly lower triangular
//printf("L strictly lower triangular.\n");
CHECK( magma_zmtransfer( L, &LL, Magma_CPU, Magma_CPU, queue ));
magma_free_cpu( LL.col );
magma_free_cpu( LL.val );
LL.nnz = L.nnz+L.num_rows;
CHECK( magma_zmalloc_cpu( &LL.val, LL.nnz ));
CHECK( magma_index_malloc_cpu( &LL.col, LL.nnz ));
magma_int_t z=0;
for (i=0; i < L.num_rows; i++) {
LL.row[i] = z;
for (j=L.row[i]; j < L.row[i+1]; j++) {
LL.val[z] = L.val[j];
LL.col[z] = L.col[j];
z++;
}
// add unit diagonal
LL.val[z] = MAGMA_Z_MAKE(1.0, 0.0);
LL.col[z] = i;
z++;
}
LL.row[LL.num_rows] = z;
}
else {
printf("error: L neither lower nor strictly lower triangular!\n");
}
CHECK( magma_zmtransfer( LL, &L_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( U, &U_d, Magma_CPU, Magma_DEV, queue ));
magma_zmfree( &LL, queue );
CHECK( magma_z_spmm( one, L_d, U_d, &LU_d, queue ));
CHECK( magma_zmtransfer(LU_d, LU, Magma_DEV, Magma_CPU, queue ));
magma_zmfree( &L_d, queue );
magma_zmfree( &U_d, queue );
magma_zmfree( &LU_d, queue );
// compute Frobenius norm of A-LU
for(i=0; i<A.num_rows; i++){
for(j=A.row[i]; j<A.row[i+1]; j++){
magma_index_t lcol = A.col[j];
for(k=LU->row[i]; k<LU->row[i+1]; k++){
if( LU->col[k] == lcol ){
tmp = MAGMA_Z_MAKE(
MAGMA_Z_REAL( LU->val[k] )- MAGMA_Z_REAL( A.val[j] )
, 0.0 );
LU->val[k] = tmp;
tmp2 = (real_Double_t) fabs( MAGMA_Z_REAL(tmp) );
(*nonlinres) = (*nonlinres) + tmp2*tmp2;
}
}
}
}
for(i=0; i<LU->num_rows; i++){
for(j=LU->row[i]; j<LU->row[i+1]; j++){
tmp2 = (real_Double_t) fabs( MAGMA_Z_REAL(LU->val[j]) );
(*res) = (*res) + tmp2* tmp2;
}
}
(*res) = sqrt((*res));
(*nonlinres) = sqrt((*nonlinres));
cleanup:
if( info !=0 ){
magma_zmfree( LU, queue );
}
magma_zmfree( &LL, queue );
magma_zmfree( &L_d, queue );
magma_zmfree( &U_d, queue );
magma_zmfree( &LU_d, queue );
return info;
}
magma_int_t
magma_zicres(
magma_z_matrix A,
magma_z_matrix C,
magma_z_matrix CT,
magma_z_matrix *LU,
real_Double_t *res,
real_Double_t *nonlinres,
magma_queue_t queue )
{
magma_int_t info = 0;
magmaDoubleComplex tmp;
real_Double_t tmp2;
magma_int_t i,j,k;
magmaDoubleComplex one = MAGMA_Z_MAKE( 1.0, 0.0 );
magma_z_matrix L_d={Magma_CSR}, U_d={Magma_CSR}, LU_d={Magma_CSR};
*res = 0.0;
*nonlinres = 0.0;
CHECK( magma_zmtransfer( C, &L_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( CT, &U_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_z_spmm( one, L_d, U_d, &LU_d, queue ));
CHECK( magma_zmtransfer(LU_d, LU, Magma_DEV, Magma_CPU, queue ));
magma_zmfree( &LU_d, queue );
// compute Frobenius norm of A-LU
for(i=0; i<A.num_rows; i++){
for(j=A.row[i]; j<A.row[i+1]; j++){
magma_index_t lcol = A.col[j];
for(k=LU->row[i]; k<LU->row[i+1]; k++){
if( LU->col[k] == lcol ){
tmp = MAGMA_Z_MAKE(
MAGMA_Z_REAL( LU->val[k] )- MAGMA_Z_REAL( A.val[j] )
, 0.0 );
LU->val[k] = tmp;
tmp2 = (real_Double_t) fabs( MAGMA_Z_REAL(tmp) );
(*nonlinres) = (*nonlinres) + tmp2*tmp2;
}
}
}
}
for(i=0; i<LU->num_rows; i++){
for(j=LU->row[i]; j<LU->row[i+1]; j++){
tmp2 = (real_Double_t) fabs( MAGMA_Z_REAL(LU->val[j]) );
(*res) = (*res) + tmp2* tmp2;
}
}
(*res) = sqrt((*res));
(*nonlinres) = sqrt((*nonlinres));
cleanup:
if( info !=0 ){
magma_zmfree( LU, queue );
}
magma_zmfree( &L_d, queue );
magma_zmfree( &U_d, queue );
magma_zmfree( &LU_d, queue );
return info;
}
extern "C" magma_int_t
magma_zqmr_merge(
magma_z_matrix A, magma_z_matrix b, magma_z_matrix *x,
magma_z_solver_par *solver_par,
magma_queue_t queue )
{
magma_int_t info = MAGMA_NOTCONVERGED;
// prepare solver feedback
solver_par->solver = Magma_QMRMERGE;
solver_par->numiter = 0;
solver_par->spmv_count = 0;
// local variables
magmaDoubleComplex c_zero = MAGMA_Z_ZERO, c_one = MAGMA_Z_ONE;
// solver variables
double nom0, r0, res=0, nomb;
magmaDoubleComplex rho = c_one, rho1 = c_one, eta = -c_one , pds = c_one,
thet = c_one, thet1 = c_one, epsilon = c_one,
beta = c_one, delta = c_one, pde = c_one, rde = c_one,
gamm = c_one, gamm1 = c_one, psi = c_one;
magma_int_t dofs = A.num_rows* b.num_cols;
// need to transpose the matrix
magma_z_matrix AT={Magma_CSR}, Ah1={Magma_CSR}, Ah2={Magma_CSR};
// GPU workspace
magma_z_matrix r={Magma_CSR}, r_tld={Magma_CSR},
v={Magma_CSR}, w={Magma_CSR}, wt={Magma_CSR},
d={Magma_CSR}, s={Magma_CSR}, z={Magma_CSR}, q={Magma_CSR},
p={Magma_CSR}, pt={Magma_CSR}, y={Magma_CSR};
CHECK( magma_zvinit( &r, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &r_tld, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &v, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &w, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &wt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &d, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &s, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &z, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &q, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &p, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &pt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &y, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
// solver setup
CHECK( magma_zresidualvec( A, b, *x, &r, &nom0, queue));
solver_par->init_res = nom0;
magma_zcopy( dofs, r.dval, 1, r_tld.dval, 1, queue );
magma_zcopy( dofs, r.dval, 1, y.dval, 1, queue );
magma_zcopy( dofs, r.dval, 1, v.dval, 1, queue );
magma_zcopy( dofs, r.dval, 1, wt.dval, 1, queue );
magma_zcopy( dofs, r.dval, 1, z.dval, 1, queue );
// transpose the matrix
magma_zmtransfer( A, &Ah1, Magma_DEV, Magma_CPU, queue );
magma_zmconvert( Ah1, &Ah2, A.storage_type, Magma_CSR, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransposeconjugate( Ah2, &Ah1, queue );
magma_zmfree(&Ah2, queue );
Ah2.blocksize = A.blocksize;
Ah2.alignment = A.alignment;
magma_zmconvert( Ah1, &Ah2, Magma_CSR, A.storage_type, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransfer( Ah2, &AT, Magma_CPU, Magma_DEV, queue );
magma_zmfree(&Ah2, queue );
nomb = magma_dznrm2( dofs, b.dval, 1, queue );
if ( nomb == 0.0 ){
nomb=1.0;
}
if ( (r0 = nomb * solver_par->rtol) < ATOLERANCE ){
r0 = ATOLERANCE;
}
solver_par->final_res = solver_par->init_res;
solver_par->iter_res = solver_par->init_res;
if ( solver_par->verbose > 0 ) {
solver_par->res_vec[0] = (real_Double_t)nom0;
solver_par->timing[0] = 0.0;
}
if ( nom0 < r0 ) {
info = MAGMA_SUCCESS;
goto cleanup;
}
psi = magma_zsqrt( magma_zdotc( dofs, z.dval, 1, z.dval, 1, queue ));
rho = magma_zsqrt( magma_zdotc( dofs, y.dval, 1, y.dval, 1, queue ));
// v = y / rho
// y = y / rho
// w = wt / psi
// z = z / psi
magma_zqmr_1(
r.num_rows,
r.num_cols,
rho,
psi,
y.dval,
z.dval,
v.dval,
w.dval,
queue );
//Chronometry
real_Double_t tempo1, tempo2;
tempo1 = magma_sync_wtime( queue );
solver_par->numiter = 0;
solver_par->spmv_count = 0;
// start iteration
do
{
solver_par->numiter++;
if( magma_z_isnan_inf( rho ) || magma_z_isnan_inf( psi ) ){
info = MAGMA_DIVERGENCE;
break;
}
// delta = z' * y;
delta = magma_zdotc( dofs, z.dval, 1, y.dval, 1, queue );
if( magma_z_isnan_inf( delta ) ){
info = MAGMA_DIVERGENCE;
break;
}
// no precond: yt = y, zt = z
//magma_zcopy( dofs, y.dval, 1, yt.dval, 1 );
//magma_zcopy( dofs, z.dval, 1, zt.dval, 1 );
if( solver_par->numiter == 1 ){
// p = y;
// q = z;
magma_zcopy( dofs, y.dval, 1, p.dval, 1, queue );
magma_zcopy( dofs, z.dval, 1, q.dval, 1, queue );
}
else{
pde = psi * delta / epsilon;
rde = rho * MAGMA_Z_CONJ(delta/epsilon);
// p = y - pde * p
// q = z - rde * q
magma_zqmr_2(
r.num_rows,
r.num_cols,
pde,
rde,
y.dval,
z.dval,
p.dval,
q.dval,
queue );
}
if( magma_z_isnan_inf( rho ) || magma_z_isnan_inf( psi ) ){
info = MAGMA_DIVERGENCE;
break;
}
CHECK( magma_z_spmv( c_one, A, p, c_zero, pt, queue ));
solver_par->spmv_count++;
// epsilon = q' * pt;
epsilon = magma_zdotc( dofs, q.dval, 1, pt.dval, 1, queue );
beta = epsilon / delta;
if( magma_z_isnan_inf( epsilon ) || magma_z_isnan_inf( beta ) ){
info = MAGMA_DIVERGENCE;
break;
}
// v = pt - beta * v
// y = v
magma_zqmr_3(
r.num_rows,
r.num_cols,
beta,
pt.dval,
v.dval,
y.dval,
queue );
rho1 = rho;
// rho = norm(y);
rho = magma_zsqrt( magma_zdotc( dofs, y.dval, 1, y.dval, 1, queue ));
// wt = A' * q - beta' * w;
CHECK( magma_z_spmv( c_one, AT, q, c_zero, wt, queue ));
solver_par->spmv_count++;
magma_zaxpy( dofs, - MAGMA_Z_CONJ( beta ), w.dval, 1, wt.dval, 1, queue );
// no precond: z = wt
magma_zcopy( dofs, wt.dval, 1, z.dval, 1, queue );
thet1 = thet;
thet = rho / (gamm * MAGMA_Z_MAKE( MAGMA_Z_ABS(beta), 0.0 ));
gamm1 = gamm;
gamm = c_one / magma_zsqrt(c_one + thet*thet);
eta = - eta * rho1 * gamm * gamm / (beta * gamm1 * gamm1);
if( magma_z_isnan_inf( thet ) || magma_z_isnan_inf( gamm ) || magma_z_isnan_inf( eta ) ){
info = MAGMA_DIVERGENCE;
break;
}
if( solver_par->numiter == 1 ){
// d = eta * p + pds * d;
// s = eta * pt + pds * d;
// x = x + d;
// r = r - s;
magma_zqmr_4(
r.num_rows,
r.num_cols,
eta,
p.dval,
pt.dval,
d.dval,
s.dval,
x->dval,
r.dval,
queue );
}
else{
pds = (thet1 * gamm) * (thet1 * gamm);
// d = eta * p + pds * d;
// s = eta * pt + pds * d;
// x = x + d;
// r = r - s;
magma_zqmr_5(
r.num_rows,
r.num_cols,
eta,
pds,
p.dval,
pt.dval,
d.dval,
s.dval,
x->dval,
r.dval,
queue );
}
// psi = norm(z);
psi = magma_zsqrt( magma_zdotc( dofs, z.dval, 1, z.dval, 1, queue ) );
res = magma_dznrm2( dofs, r.dval, 1, queue );
if ( solver_par->verbose > 0 ) {
tempo2 = magma_sync_wtime( queue );
if ( (solver_par->numiter)%solver_par->verbose == c_zero ) {
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) res;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) tempo2-tempo1;
}
}
// v = y / rho
// y = y / rho
// w = wt / psi
// z = z / psi
magma_zqmr_1(
r.num_rows,
r.num_cols,
rho,
psi,
y.dval,
z.dval,
v.dval,
w.dval,
queue );
if ( res/nomb <= solver_par->rtol || res <= solver_par->atol ){
break;
}
}
while ( solver_par->numiter+1 <= solver_par->maxiter );
tempo2 = magma_sync_wtime( queue );
solver_par->runtime = (real_Double_t) tempo2-tempo1;
double residual;
CHECK( magma_zresidualvec( A, b, *x, &r, &residual, queue));
solver_par->iter_res = res;
solver_par->final_res = residual;
if ( solver_par->numiter < solver_par->maxiter && info == MAGMA_SUCCESS ) {
info = MAGMA_SUCCESS;
} else if ( solver_par->init_res > solver_par->final_res ) {
if ( solver_par->verbose > 0 ) {
if ( (solver_par->numiter)%solver_par->verbose == c_zero ) {
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) res;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) tempo2-tempo1;
}
}
info = MAGMA_SLOW_CONVERGENCE;
if( solver_par->iter_res < solver_par->rtol*solver_par->init_res ||
solver_par->iter_res < solver_par->atol ) {
info = MAGMA_SUCCESS;
}
}
else {
if ( solver_par->verbose > 0 ) {
if ( (solver_par->numiter)%solver_par->verbose == c_zero ) {
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) res;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) tempo2-tempo1;
}
}
info = MAGMA_DIVERGENCE;
}
cleanup:
magma_zmfree(&r, queue );
magma_zmfree(&r_tld, queue );
magma_zmfree(&v, queue );
magma_zmfree(&w, queue );
magma_zmfree(&wt, queue );
magma_zmfree(&d, queue );
magma_zmfree(&s, queue );
magma_zmfree(&z, queue );
magma_zmfree(&q, queue );
magma_zmfree(&p, queue );
magma_zmfree(&pt, queue );
magma_zmfree(&y, queue );
magma_zmfree(&AT, queue );
magma_zmfree(&Ah1, queue );
magma_zmfree(&Ah2, queue );
solver_par->info = info;
return info;
} /* magma_zqmr_merge */
/* ////////////////////////////////////////////////////////////////////////////
-- testing any solver
*/
int main( int argc, char** argv )
{
magma_int_t info = 0;
TESTING_INIT();
magma_zopts zopts;
magma_queue_t queue=NULL;
magma_queue_create( /*devices[ opts->device ],*/ &queue );
magmaDoubleComplex one = MAGMA_Z_MAKE(1.0, 0.0);
magmaDoubleComplex zero = MAGMA_Z_MAKE(0.0, 0.0);
magma_z_matrix A={Magma_CSR}, B={Magma_CSR}, B_d={Magma_CSR};
magma_z_matrix x={Magma_CSR}, b={Magma_CSR};
int i=1;
CHECK( magma_zparse_opts( argc, argv, &zopts, &i, queue ));
B.blocksize = zopts.blocksize;
B.alignment = zopts.alignment;
if ( zopts.solver_par.solver != Magma_PCG &&
zopts.solver_par.solver != Magma_PGMRES &&
zopts.solver_par.solver != Magma_PBICGSTAB &&
zopts.solver_par.solver != Magma_ITERREF &&
zopts.solver_par.solver != Magma_LOBPCG )
zopts.precond_par.solver = Magma_NONE;
CHECK( magma_zsolverinfo_init( &zopts.solver_par, &zopts.precond_par, queue ));
while( i < argc ) {
if ( strcmp("LAPLACE2D", argv[i]) == 0 && i+1 < argc ) { // Laplace test
i++;
magma_int_t laplace_size = atoi( argv[i] );
CHECK( magma_zm_5stencil( laplace_size, &A, queue ));
} else { // file-matrix test
CHECK( magma_z_csr_mtx( &A, argv[i], queue ));
}
printf( "\n# matrix info: %d-by-%d with %d nonzeros\n\n",
(int) A.num_rows,(int) A.num_cols,(int) A.nnz );
// for the eigensolver case
zopts.solver_par.ev_length = A.num_rows;
CHECK( magma_zeigensolverinfo_init( &zopts.solver_par, queue ));
// scale matrix
CHECK( magma_zmscale( &A, zopts.scaling, queue ));
CHECK( magma_zmconvert( A, &B, Magma_CSR, zopts.output_format, queue ));
CHECK( magma_zmtransfer( B, &B_d, Magma_CPU, Magma_DEV, queue ));
// vectors and initial guess
CHECK( magma_zvinit( &b, Magma_DEV, A.num_cols, 1, one, queue ));
//magma_zvinit( &x, Magma_DEV, A.num_cols, 1, one, queue );
//magma_z_spmv( one, B_d, x, zero, b, queue ); // b = A x
//magma_zmfree(&x, queue );
CHECK( magma_zvinit( &x, Magma_DEV, A.num_cols, 1, zero, queue ));
info = magma_z_solver( B_d, b, &x, &zopts, queue );
if( info != 0 ){
printf("error: solver returned: %s (%d).\n",
magma_strerror( info ), info );
}
magma_zsolverinfo( &zopts.solver_par, &zopts.precond_par, queue );
magma_zmfree(&B_d, queue );
magma_zmfree(&B, queue );
magma_zmfree(&A, queue );
magma_zmfree(&x, queue );
magma_zmfree(&b, queue );
i++;
}
cleanup:
magma_zmfree(&B_d, queue );
magma_zmfree(&B, queue );
magma_zmfree(&A, queue );
magma_zmfree(&x, queue );
magma_zmfree(&b, queue );
magma_zsolverinfo_free( &zopts.solver_par, &zopts.precond_par, queue );
magma_queue_destroy( queue );
TESTING_FINALIZE();
return info;
}
extern "C" magma_int_t
magma_zbaiter_overlap(
magma_z_matrix A,
magma_z_matrix b,
magma_z_matrix *x,
magma_z_solver_par *solver_par,
magma_z_preconditioner *precond_par,
magma_queue_t queue )
{
magma_int_t info = MAGMA_NOTCONVERGED;
// prepare solver feedback
solver_par->solver = Magma_BAITERO;
// some useful variables
magmaDoubleComplex c_zero = MAGMA_Z_ZERO;
// initial residual
real_Double_t tempo1, tempo2, runtime=0;
double residual;
magma_int_t localiter = precond_par->maxiter;
magma_z_matrix Ah={Magma_CSR}, ACSR={Magma_CSR}, A_d={Magma_CSR}, r={Magma_CSR},
D={Magma_CSR}, R={Magma_CSR};
// setup
magma_int_t matrices;
matrices = precond_par->levels;
struct magma_z_matrix D_d[ 256 ];
struct magma_z_matrix R_d[ 256 ];
magma_int_t overlap;
magma_int_t blocksize = 256;
if( matrices==2 ||
matrices==4 ||
matrices==8 ||
matrices==16 ||
matrices==32 ||
matrices==64 ||
matrices==128 ){
overlap = blocksize/matrices;
}else if( matrices == 1){
overlap = 0;
}else{
printf("error: overlap ratio not supported.\n");
goto cleanup;
}
CHECK( magma_zmtransfer( A, &Ah, A.memory_location, Magma_CPU, queue ));
CHECK( magma_zmconvert( Ah, &ACSR, Ah.storage_type, Magma_CSR, queue ));
CHECK( magma_zmtransfer( ACSR, &A_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zvinit( &r, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zresidualvec( A_d, b, *x, &r, &residual, queue));
solver_par->init_res = residual;
if ( solver_par->verbose > 0 ) {
solver_par->res_vec[0] = (real_Double_t) residual;
}
// setup
for( int i=0; i<matrices; i++ ){
CHECK( magma_zcsrsplit( i*overlap, 256, ACSR, &D, &R, queue ));
CHECK( magma_zmtransfer( D, &D_d[i], Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( R, &R_d[i], Magma_CPU, Magma_DEV, queue ));
magma_zmfree(&D, queue );
magma_zmfree(&R, queue );
}
magma_int_t iterinc;
if( solver_par->verbose == 0 ){
iterinc = solver_par->maxiter;
}
else{
iterinc = solver_par->verbose;
}
solver_par->numiter = 0;
solver_par->spmv_count = 0;
// block-asynchronous iteration iterator
do
{
tempo1 = magma_sync_wtime( queue );
solver_par->numiter+= iterinc;
for( int z=0; z<iterinc; z++){
CHECK( magma_zbajac_csr_overlap( localiter, matrices, overlap, D_d, R_d, b, x, queue ));
}
tempo2 = magma_sync_wtime( queue );
runtime += tempo2-tempo1;
if ( solver_par->verbose > 0 ) {
CHECK( magma_zresidualvec( A_d, b, *x, &r, &residual, queue));
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) residual;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) runtime;
}
}
while ( solver_par->numiter+1 <= solver_par->maxiter );
solver_par->runtime = runtime;
CHECK( magma_zresidual( A_d, b, *x, &residual, queue));
solver_par->final_res = residual;
solver_par->numiter = solver_par->maxiter;
if ( solver_par->init_res > solver_par->final_res ){
info = MAGMA_SUCCESS;
}
else {
info = MAGMA_DIVERGENCE;
}
cleanup:
magma_zmfree(&r, queue );
magma_zmfree(&D, queue );
magma_zmfree(&R, queue );
for( int i=0; i<matrices; i++ ){
magma_zmfree(&D_d[i], queue );
magma_zmfree(&R_d[i], queue );
}
magma_zmfree(&A_d, queue );
magma_zmfree(&ACSR, queue );
magma_zmfree(&Ah, queue );
solver_par->info = info;
return info;
} /* magma_zbaiter_overlap */
extern "C" magma_int_t
magma_zcumilugeneratesolverinfo(
magma_z_preconditioner *precond,
magma_queue_t queue )
{
magma_int_t info = 0;
cusparseHandle_t cusparseHandle=NULL;
cusparseMatDescr_t descrL=NULL;
cusparseMatDescr_t descrU=NULL;
magma_z_matrix hA={Magma_CSR}, hL={Magma_CSR}, hU={Magma_CSR};
if (precond->L.memory_location != Magma_DEV ){
CHECK( magma_zmtransfer( precond->M, &hA,
precond->M.memory_location, Magma_CPU, queue ));
hL.diagorder_type = Magma_UNITY;
CHECK( magma_zmconvert( hA, &hL , Magma_CSR, Magma_CSRL, queue ));
hU.diagorder_type = Magma_VALUE;
CHECK( magma_zmconvert( hA, &hU , Magma_CSR, Magma_CSRU, queue ));
CHECK( magma_zmtransfer( hL, &(precond->L), Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( hU, &(precond->U), Magma_CPU, Magma_DEV, queue ));
magma_zmfree(&hA, queue );
magma_zmfree(&hL, queue );
magma_zmfree(&hU, queue );
}
// CUSPARSE context //
CHECK_CUSPARSE( cusparseCreate( &cusparseHandle ));
CHECK_CUSPARSE( cusparseSetStream( cusparseHandle, queue->cuda_stream() ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrL ));
CHECK_CUSPARSE( cusparseSetMatType( descrL, CUSPARSE_MATRIX_TYPE_TRIANGULAR ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrL, CUSPARSE_DIAG_TYPE_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrL, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrL, CUSPARSE_FILL_MODE_LOWER ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoL ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_NON_TRANSPOSE, precond->L.num_rows,
precond->L.nnz, descrL,
precond->L.dval, precond->L.drow, precond->L.dcol, precond->cuinfoL ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrU ));
CHECK_CUSPARSE( cusparseSetMatType( descrU, CUSPARSE_MATRIX_TYPE_TRIANGULAR ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrU, CUSPARSE_DIAG_TYPE_NON_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrU, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrU, CUSPARSE_FILL_MODE_UPPER ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoU ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_NON_TRANSPOSE, precond->U.num_rows,
precond->U.nnz, descrU,
precond->U.dval, precond->U.drow, precond->U.dcol, precond->cuinfoU ));
if( precond->maxiter < 50 ){
//prepare for iterative solves
// extract the diagonal of L into precond->d
CHECK( magma_zjacobisetup_diagscal( precond->L, &precond->d, queue ));
CHECK( magma_zvinit( &precond->work1, Magma_DEV, precond->U.num_rows, 1, MAGMA_Z_ZERO, queue ));
// extract the diagonal of U into precond->d2
CHECK( magma_zjacobisetup_diagscal( precond->U, &precond->d2, queue ));
CHECK( magma_zvinit( &precond->work2, Magma_DEV, precond->U.num_rows, 1, MAGMA_Z_ZERO, queue ));
}
cleanup:
cusparseDestroyMatDescr( descrL );
cusparseDestroyMatDescr( descrU );
cusparseDestroy( cusparseHandle );
return info;
}
extern "C" magma_int_t
magma_zcumilusetup_transpose(
magma_z_matrix A,
magma_z_preconditioner *precond,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix Ah1={Magma_CSR}, Ah2={Magma_CSR};
cusparseHandle_t cusparseHandle=NULL;
cusparseMatDescr_t descrLT=NULL;
cusparseMatDescr_t descrUT=NULL;
// CUSPARSE context //
CHECK_CUSPARSE( cusparseCreate( &cusparseHandle ));
CHECK_CUSPARSE( cusparseSetStream( cusparseHandle, queue->cuda_stream() ));
// transpose the matrix
magma_zmtransfer( precond->L, &Ah1, Magma_DEV, Magma_CPU, queue );
magma_zmconvert( Ah1, &Ah2, A.storage_type, Magma_CSR, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransposeconjugate( Ah2, &Ah1, queue );
magma_zmfree(&Ah2, queue );
Ah2.blocksize = A.blocksize;
Ah2.alignment = A.alignment;
magma_zmconvert( Ah1, &Ah2, Magma_CSR, A.storage_type, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransfer( Ah2, &(precond->LT), Magma_CPU, Magma_DEV, queue );
magma_zmfree(&Ah2, queue );
magma_zmtransfer( precond->U, &Ah1, Magma_DEV, Magma_CPU, queue );
magma_zmconvert( Ah1, &Ah2, A.storage_type, Magma_CSR, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransposeconjugate( Ah2, &Ah1, queue );
magma_zmfree(&Ah2, queue );
Ah2.blocksize = A.blocksize;
Ah2.alignment = A.alignment;
magma_zmconvert( Ah1, &Ah2, Magma_CSR, A.storage_type, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransfer( Ah2, &(precond->UT), Magma_CPU, Magma_DEV, queue );
magma_zmfree(&Ah2, queue );
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrLT ));
CHECK_CUSPARSE( cusparseSetMatType( descrLT, CUSPARSE_MATRIX_TYPE_TRIANGULAR ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrLT, CUSPARSE_DIAG_TYPE_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrLT, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrLT, CUSPARSE_FILL_MODE_UPPER ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoLT ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_NON_TRANSPOSE, precond->LT.num_rows,
precond->LT.nnz, descrLT,
precond->LT.dval, precond->LT.drow, precond->LT.dcol, precond->cuinfoLT ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrUT ));
CHECK_CUSPARSE( cusparseSetMatType( descrUT, CUSPARSE_MATRIX_TYPE_TRIANGULAR ));
CHECK_CUSPARSE( cusparseSetMatDiagType( descrUT, CUSPARSE_DIAG_TYPE_NON_UNIT ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrUT, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatFillMode( descrUT, CUSPARSE_FILL_MODE_LOWER ));
CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoUT ));
CHECK_CUSPARSE( cusparseZcsrsm_analysis( cusparseHandle,
CUSPARSE_OPERATION_NON_TRANSPOSE, precond->UT.num_rows,
precond->UT.nnz, descrUT,
precond->UT.dval, precond->UT.drow, precond->UT.dcol, precond->cuinfoUT ));
cleanup:
cusparseDestroyMatDescr( descrLT );
cusparseDestroyMatDescr( descrUT );
cusparseDestroy( cusparseHandle );
magma_zmfree(&Ah1, queue );
magma_zmfree(&Ah2, queue );
return info;
}
extern "C" magma_int_t
magma_zcuspmm(
magma_z_matrix A, magma_z_matrix B,
magma_z_matrix *AB,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_z_matrix C={Magma_CSR};
C.num_rows = A.num_rows;
C.num_cols = B.num_cols;
C.storage_type = A.storage_type;
C.memory_location = A.memory_location;
C.fill_mode = MagmaFull;
C.val = NULL;
C.col = NULL;
C.row = NULL;
C.rowidx = NULL;
C.blockinfo = NULL;
C.diag = NULL;
C.dval = NULL;
C.dcol = NULL;
C.drow = NULL;
C.drowidx = NULL;
C.ddiag = NULL;
magma_index_t base_t, nnz_t, baseC;
cusparseHandle_t handle=NULL;
cusparseMatDescr_t descrA=NULL;
cusparseMatDescr_t descrB=NULL;
cusparseMatDescr_t descrC=NULL;
if ( A.memory_location == Magma_DEV
&& B.memory_location == Magma_DEV
&& ( A.storage_type == Magma_CSR ||
A.storage_type == Magma_CSRCOO )
&& ( B.storage_type == Magma_CSR ||
B.storage_type == Magma_CSRCOO ) )
{
// CUSPARSE context /
CHECK_CUSPARSE( cusparseCreate( &handle ));
CHECK_CUSPARSE( cusparseSetStream( handle, queue->cuda_stream() ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrA ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrB ));
CHECK_CUSPARSE( cusparseCreateMatDescr( &descrC ));
CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_GENERAL ));
CHECK_CUSPARSE( cusparseSetMatType( descrB, CUSPARSE_MATRIX_TYPE_GENERAL ));
CHECK_CUSPARSE( cusparseSetMatType( descrC, CUSPARSE_MATRIX_TYPE_GENERAL ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrB, CUSPARSE_INDEX_BASE_ZERO ));
CHECK_CUSPARSE( cusparseSetMatIndexBase( descrC, CUSPARSE_INDEX_BASE_ZERO ));
// nnzTotalDevHostPtr points to host memory
magma_index_t *nnzTotalDevHostPtr = (magma_index_t*) &C.nnz;
CHECK_CUSPARSE( cusparseSetPointerMode( handle, CUSPARSE_POINTER_MODE_HOST ));
CHECK( magma_index_malloc( &C.drow, (A.num_rows + 1) ));
CHECK_CUSPARSE( cusparseXcsrgemmNnz( handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
CUSPARSE_OPERATION_NON_TRANSPOSE,
A.num_rows, B.num_cols, A.num_cols,
descrA, A.nnz, A.drow, A.dcol,
descrB, B.nnz, B.drow, B.dcol,
descrC, C.drow, nnzTotalDevHostPtr ));
if (NULL != nnzTotalDevHostPtr) {
C.nnz = *nnzTotalDevHostPtr;
} else {
// workaround as nnz and base C are magma_int_t
magma_index_getvector( 1, C.drow+C.num_rows, 1, &nnz_t, 1, queue );
magma_index_getvector( 1, C.drow, 1, &base_t, 1, queue );
C.nnz = (magma_int_t) nnz_t;
baseC = (magma_int_t) base_t;
C.nnz -= baseC;
}
CHECK( magma_index_malloc( &C.dcol, C.nnz ));
CHECK( magma_zmalloc( &C.dval, C.nnz ));
CHECK_CUSPARSE( cusparseZcsrgemm( handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
CUSPARSE_OPERATION_NON_TRANSPOSE,
A.num_rows, B.num_cols, A.num_cols,
descrA, A.nnz,
A.dval, A.drow, A.dcol,
descrB, B.nnz,
B.dval, B.drow, B.dcol,
descrC,
C.dval, C.drow, C.dcol ));
// end CUSPARSE context //
//magma_device_sync();
magma_queue_sync( queue );
CHECK( magma_zmtransfer( C, AB, Magma_DEV, Magma_DEV, queue ));
}
else {
info = MAGMA_ERR_NOT_SUPPORTED;
}
cleanup:
cusparseDestroyMatDescr( descrA );
cusparseDestroyMatDescr( descrB );
cusparseDestroyMatDescr( descrC );
cusparseDestroy( handle );
magma_zmfree( &C, queue );
return info;
}
/* ////////////////////////////////////////////////////////////////////////////
-- testing any solver
*/
int main( int argc, char** argv )
{
magma_int_t info = 0;
TESTING_INIT();
magma_queue_t queue=NULL;
magma_queue_create( 0, &queue );
magmaDoubleComplex one = MAGMA_Z_MAKE(1.0, 0.0);
magmaDoubleComplex zero = MAGMA_Z_MAKE(0.0, 0.0);
magma_z_matrix A={Magma_CSR}, B_d={Magma_CSR};
magma_z_matrix x={Magma_CSR}, b={Magma_CSR};
int i=1;
while( i < argc ) {
if ( strcmp("LAPLACE2D", argv[i]) == 0 && i+1 < argc ) { // Laplace test
i++;
magma_int_t laplace_size = atoi( argv[i] );
CHECK( magma_zm_5stencil( laplace_size, &A, queue ));
} else { // file-matrix test
CHECK( magma_z_csr_mtx( &A, argv[i], queue ));
}
printf( "\n# matrix info: %d-by-%d with %d nonzeros\n\n",
int(A.num_rows), int(A.num_cols), int(A.nnz) );
magma_int_t n = A.num_rows;
CHECK( magma_zmtransfer( A, &B_d, Magma_CPU, Magma_DEV, queue ));
// vectors and initial guess
CHECK( magma_zvinit( &b, Magma_DEV, A.num_cols, 1, zero, queue ));
CHECK( magma_zvinit( &x, Magma_DEV, A.num_cols, 1, one, queue ));
CHECK( magma_zprint_vector( b, 90, 10, queue ));
CHECK( magma_zprint_matrix( A, queue ));
printf("\n\n\n");
CHECK( magma_zprint_matrix( B_d, queue ));
double res;
res = magma_dznrm2(n, b.dval, 1, queue );
printf("norm0: %f\n", res);
CHECK( magma_z_spmv( one, B_d, x, zero, b, queue )); // b = A x
CHECK( magma_zprint_vector( b, 0, 100, queue ));
CHECK( magma_zprint_vector( b, b.num_rows-10, 10, queue ));
res = magma_dznrm2( n, b.dval, 1, queue );
printf("norm: %f\n", res);
CHECK( magma_zresidual( B_d, x, b, &res, queue));
printf("res: %f\n", res);
magma_zmfree(&B_d, queue );
magma_zmfree(&A, queue );
magma_zmfree(&x, queue );
magma_zmfree(&b, queue );
i++;
}
cleanup:
magma_zmfree(&A, queue );
magma_zmfree(&B_d, queue );
magma_zmfree(&x, queue );
magma_zmfree(&b, queue );
magma_queue_destroy( queue );
magma_finalize();
return info;
}
extern "C" magma_int_t
magma_zmlumerge(
magma_z_matrix L,
magma_z_matrix U,
magma_z_matrix *A,
magma_queue_t queue )
{
magma_int_t info = 0;
if( L.storage_type == Magma_CSR && U.storage_type == Magma_CSR ){
if( L.memory_location == Magma_CPU && U.memory_location == Magma_CPU ){
CHECK( magma_zmtransfer( L, A, Magma_CPU, Magma_CPU, queue ));
magma_free_cpu( A->col );
magma_free_cpu( A->val );
// make sure it is strictly lower triangular
magma_int_t z = 0;
for(magma_int_t i=0; i<A->num_rows; i++){
for(magma_int_t j=L.row[i]; j<L.row[i+1]; j++){
if( L.col[j] < i ){// make sure it is strictly lower triangular
z++;
}
}
for(magma_int_t j=U.row[i]; j<U.row[i+1]; j++){
z++;
}
}
A->nnz = z;
// fill A with the new structure;
CHECK( magma_index_malloc_cpu( &A->col, A->nnz ));
CHECK( magma_zmalloc_cpu( &A->val, A->nnz ));
z = 0;
for(magma_int_t i=0; i<A->num_rows; i++){
A->row[i] = z;
for(magma_int_t j=L.row[i]; j<L.row[i+1]; j++){
if( L.col[j] < i ){// make sure it is strictly lower triangular
A->col[z] = L.col[j];
A->val[z] = L.val[j];
z++;
}
}
for(magma_int_t j=U.row[i]; j<U.row[i+1]; j++){
A->col[z] = U.col[j];
A->val[z] = U.val[j];
z++;
}
}
A->row[A->num_rows] = z;
A->nnz = z;
}
else{
printf("error: matrix not on CPU.\n");
info = MAGMA_ERR_NOT_SUPPORTED;
}
}
else{
printf("error: matrix in wrong format.\n");
info = MAGMA_ERR_NOT_SUPPORTED;
}
cleanup:
if( info != 0 ){
magma_zmfree( A, queue );
}
return info;
}
extern "C" magma_int_t
magma_zpidr_merge(
magma_z_matrix A, magma_z_matrix b, magma_z_matrix *x,
magma_z_solver_par *solver_par,
magma_z_preconditioner *precond_par,
magma_queue_t queue )
{
magma_int_t info = MAGMA_NOTCONVERGED;
// prepare solver feedback
solver_par->solver = Magma_PIDRMERGE;
solver_par->numiter = 0;
solver_par->spmv_count = 0;
solver_par->init_res = 0.0;
solver_par->final_res = 0.0;
solver_par->iter_res = 0.0;
solver_par->runtime = 0.0;
// constants
const magmaDoubleComplex c_zero = MAGMA_Z_ZERO;
const magmaDoubleComplex c_one = MAGMA_Z_ONE;
const magmaDoubleComplex c_n_one = MAGMA_Z_NEG_ONE;
// internal user parameters
const magma_int_t smoothing = 1; // 0 = disable, 1 = enable
const double angle = 0.7; // [0-1]
// local variables
magma_int_t iseed[4] = {0, 0, 0, 1};
magma_int_t dof;
magma_int_t s;
magma_int_t distr;
magma_int_t k, i, sk;
magma_int_t innerflag;
magma_int_t ldd;
double residual;
double nrm;
double nrmb;
double nrmr;
double nrmt;
double rho;
magmaDoubleComplex om;
magmaDoubleComplex gamma;
magmaDoubleComplex fk;
// matrices and vectors
magma_z_matrix dxs = {Magma_CSR};
magma_z_matrix dr = {Magma_CSR}, drs = {Magma_CSR};
magma_z_matrix dP = {Magma_CSR}, dP1 = {Magma_CSR};
magma_z_matrix dG = {Magma_CSR}, dGcol = {Magma_CSR};
magma_z_matrix dU = {Magma_CSR};
magma_z_matrix dM = {Magma_CSR}, hMdiag = {Magma_CSR};
magma_z_matrix df = {Magma_CSR};
magma_z_matrix dt = {Magma_CSR}, dtt = {Magma_CSR};
magma_z_matrix dc = {Magma_CSR};
magma_z_matrix dv = {Magma_CSR};
magma_z_matrix dlu = {Magma_CSR};
magma_z_matrix dskp = {Magma_CSR}, hskp = {Magma_CSR};
magma_z_matrix dalpha = {Magma_CSR}, halpha = {Magma_CSR};
magma_z_matrix dbeta = {Magma_CSR}, hbeta = {Magma_CSR};
magmaDoubleComplex *d1 = NULL, *d2 = NULL;
// chronometry
real_Double_t tempo1, tempo2;
// initial s space
// TODO: add option for 's' (shadow space number)
// Hack: uses '--restart' option as the shadow space number.
// This is not a good idea because the default value of restart option is used to detect
// if the user provided a custom restart. This means that if the default restart value
// is changed then the code will think it was the user (unless the default value is
// also updated in the 'if' statement below.
s = 1;
if ( solver_par->restart != 50 ) {
if ( solver_par->restart > A.num_cols ) {
s = A.num_cols;
} else {
s = solver_par->restart;
}
}
solver_par->restart = s;
// set max iterations
solver_par->maxiter = min( 2 * A.num_cols, solver_par->maxiter );
// check if matrix A is square
if ( A.num_rows != A.num_cols ) {
//printf("Matrix A is not square.\n");
info = MAGMA_ERR_NOT_SUPPORTED;
goto cleanup;
}
// |b|
nrmb = magma_dznrm2( b.num_rows, b.dval, 1, queue );
if ( nrmb == 0.0 ) {
magma_zscal( x->num_rows, MAGMA_Z_ZERO, x->dval, 1, queue );
info = MAGMA_SUCCESS;
goto cleanup;
}
// t = 0
// make t twice as large to contain both, dt and dr
ldd = magma_roundup( b.num_rows, 32 );
CHECK( magma_zvinit( &dt, Magma_DEV, ldd, 2, c_zero, queue ));
dt.num_rows = b.num_rows;
dt.num_cols = 1;
dt.nnz = dt.num_rows;
// redirect the dr.dval to the second part of dt
CHECK( magma_zvinit( &dr, Magma_DEV, b.num_rows, 1, c_zero, queue ));
magma_free( dr.dval );
dr.dval = dt.dval + ldd;
// r = b - A x
CHECK( magma_zresidualvec( A, b, *x, &dr, &nrmr, queue ));
// |r|
solver_par->init_res = nrmr;
solver_par->final_res = solver_par->init_res;
solver_par->iter_res = solver_par->init_res;
if ( solver_par->verbose > 0 ) {
solver_par->res_vec[0] = (real_Double_t)nrmr;
}
// check if initial is guess good enough
if ( nrmr <= solver_par->atol ||
nrmr/nrmb <= solver_par->rtol ) {
info = MAGMA_SUCCESS;
goto cleanup;
}
// P = randn(n, s)
// P = ortho(P)
//---------------------------------------
// P = 0.0
CHECK( magma_zvinit( &dP, Magma_CPU, A.num_cols, s, c_zero, queue ));
// P = randn(n, s)
distr = 3; // 1 = unif (0,1), 2 = unif (-1,1), 3 = normal (0,1)
dof = dP.num_rows * dP.num_cols;
lapackf77_zlarnv( &distr, iseed, &dof, dP.val );
// transfer P to device
CHECK( magma_zmtransfer( dP, &dP1, Magma_CPU, Magma_DEV, queue ));
magma_zmfree( &dP, queue );
// P = ortho(P1)
if ( dP1.num_cols > 1 ) {
// P = magma_zqr(P1), QR factorization
CHECK( magma_zqr( dP1.num_rows, dP1.num_cols, dP1, dP1.ld, &dP, NULL, queue ));
} else {
// P = P1 / |P1|
nrm = magma_dznrm2( dof, dP1.dval, 1, queue );
nrm = 1.0 / nrm;
magma_zdscal( dof, nrm, dP1.dval, 1, queue );
CHECK( magma_zmtransfer( dP1, &dP, Magma_DEV, Magma_DEV, queue ));
}
magma_zmfree( &dP1, queue );
//---------------------------------------
// allocate memory for the scalar products
CHECK( magma_zvinit( &hskp, Magma_CPU, 4, 1, c_zero, queue ));
CHECK( magma_zvinit( &dskp, Magma_DEV, 4, 1, c_zero, queue ));
CHECK( magma_zvinit( &halpha, Magma_CPU, s, 1, c_zero, queue ));
CHECK( magma_zvinit( &dalpha, Magma_DEV, s, 1, c_zero, queue ));
CHECK( magma_zvinit( &hbeta, Magma_CPU, s, 1, c_zero, queue ));
CHECK( magma_zvinit( &dbeta, Magma_DEV, s, 1, c_zero, queue ));
// workspace for merged dot product
CHECK( magma_zmalloc( &d1, max(2, s) * b.num_rows ));
CHECK( magma_zmalloc( &d2, max(2, s) * b.num_rows ));
// smoothing enabled
if ( smoothing > 0 ) {
// set smoothing solution vector
CHECK( magma_zmtransfer( *x, &dxs, Magma_DEV, Magma_DEV, queue ));
// tt = 0
// make tt twice as large to contain both, dtt and drs
ldd = magma_roundup( b.num_rows, 32 );
CHECK( magma_zvinit( &dtt, Magma_DEV, ldd, 2, c_zero, queue ));
dtt.num_rows = dr.num_rows;
dtt.num_cols = 1;
dtt.nnz = dtt.num_rows;
// redirect the drs.dval to the second part of dtt
CHECK( magma_zvinit( &drs, Magma_DEV, dr.num_rows, 1, c_zero, queue ));
magma_free( drs.dval );
drs.dval = dtt.dval + ldd;
// set smoothing residual vector
magma_zcopyvector( dr.num_rows, dr.dval, 1, drs.dval, 1, queue );
}
// G(n,s) = 0
if ( s > 1 ) {
ldd = magma_roundup( A.num_rows, 32 );
CHECK( magma_zvinit( &dG, Magma_DEV, ldd, s, c_zero, queue ));
dG.num_rows = A.num_rows;
} else {
CHECK( magma_zvinit( &dG, Magma_DEV, A.num_rows, s, c_zero, queue ));
}
// dGcol represents a single column of dG, array pointer is set inside loop
CHECK( magma_zvinit( &dGcol, Magma_DEV, dG.num_rows, 1, c_zero, queue ));
magma_free( dGcol.dval );
// U(n,s) = 0
if ( s > 1 ) {
ldd = magma_roundup( A.num_cols, 32 );
CHECK( magma_zvinit( &dU, Magma_DEV, ldd, s, c_zero, queue ));
dU.num_rows = A.num_cols;
} else {
CHECK( magma_zvinit( &dU, Magma_DEV, A.num_cols, s, c_zero, queue ));
}
// M(s,s) = I
CHECK( magma_zvinit( &dM, Magma_DEV, s, s, c_zero, queue ));
CHECK( magma_zvinit( &hMdiag, Magma_CPU, s, 1, c_zero, queue ));
magmablas_zlaset( MagmaFull, dM.num_rows, dM.num_cols, c_zero, c_one, dM.dval, dM.ld, queue );
// f = 0
CHECK( magma_zvinit( &df, Magma_DEV, dP.num_cols, 1, c_zero, queue ));
// c = 0
CHECK( magma_zvinit( &dc, Magma_DEV, dM.num_cols, 1, c_zero, queue ));
// v = 0
CHECK( magma_zvinit( &dv, Magma_DEV, dr.num_rows, 1, c_zero, queue ));
// lu = 0
CHECK( magma_zvinit( &dlu, Magma_DEV, dr.num_rows, 1, c_zero, queue ));
//--------------START TIME---------------
// chronometry
tempo1 = magma_sync_wtime( queue );
if ( solver_par->verbose > 0 ) {
solver_par->timing[0] = 0.0;
}
om = MAGMA_Z_ONE;
innerflag = 0;
// start iteration
do
{
solver_par->numiter++;
// new RHS for small systems
// f = P' r
magma_zgemvmdot_shfl( dP.num_rows, dP.num_cols, dP.dval, dr.dval, d1, d2, df.dval, queue );
// shadow space loop
for ( k = 0; k < s; ++k ) {
sk = s - k;
// c(k:s) = M(k:s,k:s) \ f(k:s)
magma_zcopyvector( sk, &df.dval[k], 1, &dc.dval[k], 1, queue );
magma_ztrsv( MagmaLower, MagmaNoTrans, MagmaNonUnit, sk, &dM.dval[k*dM.ld+k], dM.ld, &dc.dval[k], 1, queue );
// v = r - G(:,k:s) c(k:s)
magma_zcopyvector( dr.num_rows, dr.dval, 1, dv.dval, 1, queue );
magmablas_zgemv( MagmaNoTrans, dG.num_rows, sk, c_n_one, &dG.dval[k*dG.ld], dG.ld, &dc.dval[k], 1, c_one, dv.dval, 1, queue );
// preconditioning operation
// v = L \ v;
// v = U \ v;
CHECK( magma_z_applyprecond_left( MagmaNoTrans, A, dv, &dlu, precond_par, queue ));
CHECK( magma_z_applyprecond_right( MagmaNoTrans, A, dlu, &dv, precond_par, queue ));
// U(:,k) = om * v + U(:,k:s) c(k:s)
magmablas_zgemv( MagmaNoTrans, dU.num_rows, sk, c_one, &dU.dval[k*dU.ld], dU.ld, &dc.dval[k], 1, om, dv.dval, 1, queue );
magma_zcopyvector( dU.num_rows, dv.dval, 1, &dU.dval[k*dU.ld], 1, queue );
// G(:,k) = A U(:,k)
dGcol.dval = dG.dval + k * dG.ld;
CHECK( magma_z_spmv( c_one, A, dv, c_zero, dGcol, queue ));
solver_par->spmv_count++;
// bi-orthogonalize the new basis vectors
for ( i = 0; i < k; ++i ) {
// alpha = P(:,i)' G(:,k)
halpha.val[i] = magma_zdotc( dP.num_rows, &dP.dval[i*dP.ld], 1, &dG.dval[k*dG.ld], 1, queue );
// alpha = alpha / M(i,i)
halpha.val[i] = halpha.val[i] / hMdiag.val[i];
// G(:,k) = G(:,k) - alpha * G(:,i)
magma_zaxpy( dG.num_rows, -halpha.val[i], &dG.dval[i*dG.ld], 1, &dG.dval[k*dG.ld], 1, queue );
}
// non-first s iteration
if ( k > 0 ) {
// U update outside of loop using GEMV
// U(:,k) = U(:,k) - U(:,1:k) * alpha(1:k)
magma_zsetvector( k, halpha.val, 1, dalpha.dval, 1, queue );
magmablas_zgemv( MagmaNoTrans, dU.num_rows, k, c_n_one, dU.dval, dU.ld, dalpha.dval, 1, c_one, &dU.dval[k*dU.ld], 1, queue );
}
// new column of M = P'G, first k-1 entries are zero
// M(k:s,k) = P(:,k:s)' G(:,k)
magma_zgemvmdot_shfl( dP.num_rows, sk, &dP.dval[k*dP.ld], &dG.dval[k*dG.ld], d1, d2, &dM.dval[k*dM.ld+k], queue );
magma_zgetvector( 1, &dM.dval[k*dM.ld+k], 1, &hMdiag.val[k], 1, queue );
// check M(k,k) == 0
if ( MAGMA_Z_EQUAL(hMdiag.val[k], MAGMA_Z_ZERO) ) {
innerflag = 1;
info = MAGMA_DIVERGENCE;
break;
}
// beta = f(k) / M(k,k)
magma_zgetvector( 1, &df.dval[k], 1, &fk, 1, queue );
hbeta.val[k] = fk / hMdiag.val[k];
// check for nan
if ( magma_z_isnan( hbeta.val[k] ) || magma_z_isinf( hbeta.val[k] )) {
innerflag = 1;
info = MAGMA_DIVERGENCE;
break;
}
// r = r - beta * G(:,k)
magma_zaxpy( dr.num_rows, -hbeta.val[k], &dG.dval[k*dG.ld], 1, dr.dval, 1, queue );
// smoothing disabled
if ( smoothing <= 0 ) {
// |r|
nrmr = magma_dznrm2( dr.num_rows, dr.dval, 1, queue );
// smoothing enabled
} else {
// x = x + beta * U(:,k)
magma_zaxpy( x->num_rows, hbeta.val[k], &dU.dval[k*dU.ld], 1, x->dval, 1, queue );
// smoothing operation
//---------------------------------------
// t = rs - r
magma_zidr_smoothing_1( drs.num_rows, drs.num_cols, drs.dval, dr.dval, dtt.dval, queue );
// t't
// t'rs
CHECK( magma_zgemvmdot_shfl( dt.ld, 2, dtt.dval, dtt.dval, d1, d2, &dskp.dval[2], queue ));
magma_zgetvector( 2, &dskp.dval[2], 1, &hskp.val[2], 1, queue );
// gamma = (t' * rs) / (t' * t)
gamma = hskp.val[3] / hskp.val[2];
// rs = rs - gamma * (rs - r)
magma_zaxpy( drs.num_rows, -gamma, dtt.dval, 1, drs.dval, 1, queue );
// xs = xs - gamma * (xs - x)
magma_zidr_smoothing_2( dxs.num_rows, dxs.num_cols, -gamma, x->dval, dxs.dval, queue );
// |rs|
nrmr = magma_dznrm2( drs.num_rows, drs.dval, 1, queue );
//---------------------------------------
}
// store current timing and residual
if ( solver_par->verbose > 0 ) {
tempo2 = magma_sync_wtime( queue );
if ( (solver_par->numiter) % solver_par->verbose == 0 ) {
solver_par->res_vec[(solver_par->numiter) / solver_par->verbose]
= (real_Double_t)nrmr;
solver_par->timing[(solver_par->numiter) / solver_par->verbose]
= (real_Double_t)tempo2 - tempo1;
}
}
// check convergence or iteration limit
if ( nrmr <= solver_par->atol ||
nrmr/nrmb <= solver_par->rtol ) {
s = k + 1; // for the x-update outside the loop
innerflag = 2;
info = MAGMA_SUCCESS;
break;
}
// non-last s iteration
if ( (k + 1) < s ) {
// f(k+1:s) = f(k+1:s) - beta * M(k+1:s,k)
magma_zaxpy( sk-1, -hbeta.val[k], &dM.dval[k*dM.ld+(k+1)], 1, &df.dval[k+1], 1, queue );
}
}
// smoothing disabled
if ( smoothing <= 0 && innerflag != 1 ) {
// update solution approximation x
// x = x + U(:,1:s) * beta(1:s)
magma_zsetvector( s, hbeta.val, 1, dbeta.dval, 1, queue );
magmablas_zgemv( MagmaNoTrans, dU.num_rows, s, c_one, dU.dval, dU.ld, dbeta.dval, 1, c_one, x->dval, 1, queue );
}
// check convergence or iteration limit or invalid result of inner loop
if ( innerflag > 0 ) {
break;
}
// v = r
magma_zcopy( dr.num_rows, dr.dval, 1, dv.dval, 1, queue );
// preconditioning operation
// v = L \ v;
// v = U \ v;
CHECK( magma_z_applyprecond_left( MagmaNoTrans, A, dv, &dlu, precond_par, queue ));
CHECK( magma_z_applyprecond_right( MagmaNoTrans, A, dlu, &dv, precond_par, queue ));
// t = A v
CHECK( magma_z_spmv( c_one, A, dv, c_zero, dt, queue ));
solver_par->spmv_count++;
// computation of a new omega
//---------------------------------------
// t't
// t'r
CHECK( magma_zgemvmdot_shfl( dt.ld, 2, dt.dval, dt.dval, d1, d2, dskp.dval, queue ));
magma_zgetvector( 2, dskp.dval, 1, hskp.val, 1, queue );
// |t|
nrmt = magma_dsqrt( MAGMA_Z_REAL(hskp.val[0]) );
// rho = abs((t' * r) / (|t| * |r|))
rho = MAGMA_D_ABS( MAGMA_Z_REAL(hskp.val[1]) / (nrmt * nrmr) );
// om = (t' * r) / (|t| * |t|)
om = hskp.val[1] / hskp.val[0];
if ( rho < angle ) {
om = (om * angle) / rho;
}
//---------------------------------------
if ( MAGMA_Z_EQUAL(om, MAGMA_Z_ZERO) ) {
info = MAGMA_DIVERGENCE;
break;
}
// update approximation vector
// x = x + om * v
magma_zaxpy( x->num_rows, om, dv.dval, 1, x->dval, 1, queue );
// update residual vector
// r = r - om * t
magma_zaxpy( dr.num_rows, -om, dt.dval, 1, dr.dval, 1, queue );
// smoothing disabled
if ( smoothing <= 0 ) {
// residual norm
nrmr = magma_dznrm2( dr.num_rows, dr.dval, 1, queue );
// smoothing enabled
} else {
// smoothing operation
//---------------------------------------
// t = rs - r
magma_zidr_smoothing_1( drs.num_rows, drs.num_cols, drs.dval, dr.dval, dtt.dval, queue );
// t't
// t'rs
CHECK( magma_zgemvmdot_shfl( dt.ld, 2, dtt.dval, dtt.dval, d1, d2, &dskp.dval[2], queue ));
magma_zgetvector( 2, &dskp.dval[2], 1, &hskp.val[2], 1, queue );
// gamma = (t' * rs) / (t' * t)
gamma = hskp.val[3] / hskp.val[2];
// rs = rs - gamma * (rs - r)
magma_zaxpy( drs.num_rows, -gamma, dtt.dval, 1, drs.dval, 1, queue );
// xs = xs - gamma * (xs - x)
magma_zidr_smoothing_2( dxs.num_rows, dxs.num_cols, -gamma, x->dval, dxs.dval, queue );
// |rs|
nrmr = magma_dznrm2( drs.num_rows, drs.dval, 1, queue );
//---------------------------------------
}
// store current timing and residual
if ( solver_par->verbose > 0 ) {
tempo2 = magma_sync_wtime( queue );
if ( (solver_par->numiter) % solver_par->verbose == 0 ) {
solver_par->res_vec[(solver_par->numiter) / solver_par->verbose]
= (real_Double_t)nrmr;
solver_par->timing[(solver_par->numiter) / solver_par->verbose]
= (real_Double_t)tempo2 - tempo1;
}
}
// check convergence
if ( nrmr <= solver_par->atol ||
nrmr/nrmb <= solver_par->rtol ) {
info = MAGMA_SUCCESS;
break;
}
}
while ( solver_par->numiter + 1 <= solver_par->maxiter );
// smoothing enabled
if ( smoothing > 0 ) {
// x = xs
magma_zcopyvector( x->num_rows, dxs.dval, 1, x->dval, 1, queue );
// r = rs
magma_zcopyvector( dr.num_rows, drs.dval, 1, dr.dval, 1, queue );
}
// get last iteration timing
tempo2 = magma_sync_wtime( queue );
solver_par->runtime = (real_Double_t)tempo2 - tempo1;
//--------------STOP TIME----------------
// get final stats
solver_par->iter_res = nrmr;
CHECK( magma_zresidualvec( A, b, *x, &dr, &residual, queue ));
solver_par->final_res = residual;
// set solver conclusion
if ( info != MAGMA_SUCCESS && info != MAGMA_DIVERGENCE ) {
if ( solver_par->init_res > solver_par->final_res ) {
info = MAGMA_SLOW_CONVERGENCE;
}
}
cleanup:
// free resources
// smoothing enabled
if ( smoothing > 0 ) {
drs.dval = NULL; // needed because its pointer is redirected to dtt
magma_zmfree( &dxs, queue );
magma_zmfree( &drs, queue );
magma_zmfree( &dtt, queue );
}
dr.dval = NULL; // needed because its pointer is redirected to dt
dGcol.dval = NULL; // needed because its pointer is redirected to dG
magma_zmfree( &dr, queue );
magma_zmfree( &dP, queue );
magma_zmfree( &dP1, queue );
magma_zmfree( &dG, queue );
magma_zmfree( &dGcol, queue );
magma_zmfree( &dU, queue );
magma_zmfree( &dM, queue );
magma_zmfree( &hMdiag, queue );
magma_zmfree( &df, queue );
magma_zmfree( &dt, queue );
magma_zmfree( &dc, queue );
magma_zmfree( &dv, queue );
magma_zmfree( &dlu, queue );
magma_zmfree( &dskp, queue );
magma_zmfree( &dalpha, queue );
magma_zmfree( &dbeta, queue );
magma_zmfree( &hskp, queue );
magma_zmfree( &halpha, queue );
magma_zmfree( &hbeta, queue );
magma_free( d1 );
magma_free( d2 );
solver_par->info = info;
return info;
/* magma_zpidr_merge */
}
extern "C" magma_int_t
magma_zpbicg(
magma_z_matrix A, magma_z_matrix b, magma_z_matrix *x,
magma_z_solver_par *solver_par,
magma_z_preconditioner *precond_par,
magma_queue_t queue )
{
magma_int_t info = MAGMA_NOTCONVERGED;
// prepare solver feedback
solver_par->solver = Magma_PBICG;
solver_par->numiter = 0;
solver_par->spmv_count = 0;
// some useful variables
magmaDoubleComplex c_zero = MAGMA_Z_ZERO;
magmaDoubleComplex c_one = MAGMA_Z_ONE;
magmaDoubleComplex c_neg_one = MAGMA_Z_NEG_ONE;
magma_int_t dofs = A.num_rows * b.num_cols;
// workspace
magma_z_matrix r={Magma_CSR}, rt={Magma_CSR}, p={Magma_CSR}, pt={Magma_CSR},
z={Magma_CSR}, zt={Magma_CSR}, q={Magma_CSR}, y={Magma_CSR},
yt={Magma_CSR}, qt={Magma_CSR};
// need to transpose the matrix
magma_z_matrix AT={Magma_CSR}, Ah1={Magma_CSR}, Ah2={Magma_CSR};
CHECK( magma_zvinit( &r, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &rt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &p, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &pt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &q, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &qt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &y, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &yt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &z, Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
CHECK( magma_zvinit( &zt,Magma_DEV, A.num_rows, b.num_cols, c_zero, queue ));
// solver variables
magmaDoubleComplex alpha, rho, beta, rho_new, ptq;
double res, nomb, nom0, r0;
// transpose the matrix
magma_zmtransfer( A, &Ah1, Magma_DEV, Magma_CPU, queue );
magma_zmconvert( Ah1, &Ah2, A.storage_type, Magma_CSR, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransposeconjugate( Ah2, &Ah1, queue );
magma_zmfree(&Ah2, queue );
Ah2.blocksize = A.blocksize;
Ah2.alignment = A.alignment;
magma_zmconvert( Ah1, &Ah2, Magma_CSR, A.storage_type, queue );
magma_zmfree(&Ah1, queue );
magma_zmtransfer( Ah2, &AT, Magma_CPU, Magma_DEV, queue );
magma_zmfree(&Ah2, queue );
// solver setup
CHECK( magma_zresidualvec( A, b, *x, &r, &nom0, queue));
res = nom0;
solver_par->init_res = nom0;
magma_zcopy( dofs, r.dval, 1, rt.dval, 1, queue ); // rr = r
rho_new = magma_zdotc( dofs, rt.dval, 1, r.dval, 1, queue ); // rho=<rr,r>
rho = alpha = MAGMA_Z_MAKE( 1.0, 0. );
nomb = magma_dznrm2( dofs, b.dval, 1, queue );
if ( nomb == 0.0 ){
nomb=1.0;
}
if ( (r0 = nomb * solver_par->rtol) < ATOLERANCE ){
r0 = ATOLERANCE;
}
solver_par->final_res = solver_par->init_res;
solver_par->iter_res = solver_par->init_res;
if ( solver_par->verbose > 0 ) {
solver_par->res_vec[0] = nom0;
solver_par->timing[0] = 0.0;
}
if ( nom0 < r0 ) {
info = MAGMA_SUCCESS;
goto cleanup;
}
//Chronometry
real_Double_t tempo1, tempo2;
tempo1 = magma_sync_wtime( queue );
solver_par->numiter = 0;
solver_par->spmv_count = 0;
// start iteration
do
{
solver_par->numiter++;
CHECK( magma_z_applyprecond_left( MagmaNoTrans, A, r, &y, precond_par, queue ));
CHECK( magma_z_applyprecond_right( MagmaNoTrans, A, y, &z, precond_par, queue ));
CHECK( magma_z_applyprecond_right( MagmaTrans, A, rt, &yt, precond_par, queue ));
CHECK( magma_z_applyprecond_left( MagmaTrans, A, yt, &zt, precond_par, queue ));
//magma_zcopy( dofs, r.dval, 1 , y.dval, 1, queue ); // y=r
//magma_zcopy( dofs, y.dval, 1 , z.dval, 1, queue ); // z=y
//magma_zcopy( dofs, rt.dval, 1 , yt.dval, 1, queue ); // yt=rt
//magma_zcopy( dofs, yt.dval, 1 , zt.dval, 1, queue ); // yt=rt
rho= rho_new;
rho_new = magma_zdotc( dofs, rt.dval, 1, z.dval, 1, queue ); // rho=<rt,z>
if( magma_z_isnan_inf( rho_new ) ){
info = MAGMA_DIVERGENCE;
break;
}
if( solver_par->numiter==1 ){
magma_zcopy( dofs, z.dval, 1 , p.dval, 1, queue ); // yt=rt
magma_zcopy( dofs, zt.dval, 1 , pt.dval, 1, queue ); // zt=yt
} else {
beta = rho_new/rho;
magma_zscal( dofs, beta, p.dval, 1, queue ); // p = beta*p
magma_zaxpy( dofs, c_one , z.dval, 1 , p.dval, 1, queue ); // p = z+beta*p
magma_zscal( dofs, MAGMA_Z_CONJ(beta), pt.dval, 1, queue ); // pt = beta*pt
magma_zaxpy( dofs, c_one , zt.dval, 1 , pt.dval, 1, queue ); // pt = zt+beta*pt
}
CHECK( magma_z_spmv( c_one, A, p, c_zero, q, queue )); // v = Ap
CHECK( magma_z_spmv( c_one, AT, pt, c_zero, qt, queue )); // v = Ap
solver_par->spmv_count++;
solver_par->spmv_count++;
ptq = magma_zdotc( dofs, pt.dval, 1, q.dval, 1, queue );
alpha = rho_new /ptq;
magma_zaxpy( dofs, alpha, p.dval, 1 , x->dval, 1, queue ); // x=x+alpha*p
magma_zaxpy( dofs, c_neg_one * alpha, q.dval, 1 , r.dval, 1, queue ); // r=r+alpha*q
magma_zaxpy( dofs, c_neg_one * MAGMA_Z_CONJ(alpha), qt.dval, 1 , rt.dval, 1, queue ); // r=r+alpha*q
res = magma_dznrm2( dofs, r.dval, 1, queue );
if ( solver_par->verbose > 0 ) {
tempo2 = magma_sync_wtime( queue );
if ( (solver_par->numiter)%solver_par->verbose==0 ) {
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) res;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) tempo2-tempo1;
}
}
if ( res/nomb <= solver_par->rtol || res <= solver_par->atol ){
break;
}
}
while ( solver_par->numiter+1 <= solver_par->maxiter );
tempo2 = magma_sync_wtime( queue );
solver_par->runtime = (real_Double_t) tempo2-tempo1;
double residual;
CHECK( magma_zresidualvec( A, b, *x, &r, &residual, queue));
solver_par->iter_res = res;
solver_par->final_res = residual;
if ( solver_par->numiter < solver_par->maxiter ) {
info = MAGMA_SUCCESS;
} else if ( solver_par->init_res > solver_par->final_res ) {
if ( solver_par->verbose > 0 ) {
if ( (solver_par->numiter)%solver_par->verbose==0 ) {
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) res;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) tempo2-tempo1;
}
}
info = MAGMA_SLOW_CONVERGENCE;
if( solver_par->iter_res < solver_par->rtol*solver_par->init_res ||
solver_par->iter_res < solver_par->atol ) {
info = MAGMA_SUCCESS;
}
}
else {
if ( solver_par->verbose > 0 ) {
if ( (solver_par->numiter)%solver_par->verbose==0 ) {
solver_par->res_vec[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) res;
solver_par->timing[(solver_par->numiter)/solver_par->verbose]
= (real_Double_t) tempo2-tempo1;
}
}
info = MAGMA_DIVERGENCE;
}
cleanup:
magma_zmfree(&r, queue );
magma_zmfree(&rt, queue );
magma_zmfree(&p, queue );
magma_zmfree(&pt, queue );
magma_zmfree(&q, queue );
magma_zmfree(&qt, queue );
magma_zmfree(&y, queue );
magma_zmfree(&yt, queue );
magma_zmfree(&z, queue );
magma_zmfree(&zt, queue );
magma_zmfree(&AT, queue );
magma_zmfree(&Ah1, queue );
magma_zmfree(&Ah2, queue );
solver_par->info = info;
return info;
} /* magma_zpbicg */
magma_int_t
magma_znonlinres(
magma_z_matrix A,
magma_z_matrix L,
magma_z_matrix U,
magma_z_matrix *LU,
real_Double_t *res,
magma_queue_t queue )
{
magma_int_t info = 0;
real_Double_t tmp2;
magma_int_t i,j,k;
magmaDoubleComplex one = MAGMA_Z_MAKE( 1.0, 0.0 );
magma_z_matrix L_d={Magma_CSR}, U_d={Magma_CSR}, LU_d={Magma_CSR}, A_t={Magma_CSR};
CHECK( magma_zmtransfer( L, &L_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( U, &U_d, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_zmtransfer( A, &A_t, Magma_CPU, Magma_CPU, queue ));
CHECK( magma_z_spmm( one, L_d, U_d, &LU_d, queue ));
CHECK( magma_zmtransfer(LU_d, LU, Magma_DEV, Magma_CPU, queue ));
magma_zmfree( &L_d, queue );
magma_zmfree( &U_d, queue );
magma_zmfree( &LU_d, queue );
// compute Frobenius norm of A-LU
for(i=0; i<A.num_rows; i++){
for(j=A.row[i]; j<A.row[i+1]; j++){
magma_index_t lcol = A.col[j];
magmaDoubleComplex newval = MAGMA_Z_MAKE(0.0, 0.0);
for(k=LU->row[i]; k<LU->row[i+1]; k++){
if( LU->col[k] == lcol ){
newval = MAGMA_Z_MAKE(
MAGMA_Z_REAL( LU->val[k] )- MAGMA_Z_REAL( A.val[j] )
, 0.0 );
}
}
A_t.val[j] = newval;
}
}
for(i=0; i<A.num_rows; i++){
for(j=A.row[i]; j<A.row[i+1]; j++){
tmp2 = (real_Double_t) fabs( MAGMA_Z_REAL(A_t.val[j]) );
(*res) = (*res) + tmp2* tmp2;
}
}
magma_zmfree( LU, queue );
magma_zmfree( &A_t, queue );
(*res) = sqrt((*res));
cleanup:
if( info !=0 ){
magma_zmfree( LU, queue );
}
magma_zmfree( &A_t, queue );
magma_zmfree( &L_d, queue );
magma_zmfree( &U_d, queue );
magma_zmfree( &LU_d, queue );
return info;
}
