extern "C" magma_int_t
magma_z_precond(
magma_z_sparse_matrix A,
magma_z_vector b,
magma_z_vector *x,
magma_z_preconditioner *precond,
magma_queue_t queue )
{
// set up precond parameters as solver parameters
magma_z_solver_par psolver_par;
psolver_par.epsilon = precond->epsilon;
psolver_par.maxiter = precond->maxiter;
psolver_par.restart = precond->restart;
psolver_par.verbose = 0;
switch( precond->solver ) {
case Magma_CG:
magma_zcg_res( A, b, x, &psolver_par, queue );break;
case Magma_BICGSTAB:
magma_zbicgstab( A, b, x, &psolver_par, queue );break;
case Magma_GMRES:
magma_zgmres( A, b, x, &psolver_par, queue );break;
case Magma_JACOBI:
magma_zjacobi( A, b, x, &psolver_par, queue );break;
case Magma_BAITER:
magma_zbaiter( A, b, x, &psolver_par, queue );break;
}
return MAGMA_SUCCESS;
}
/* ////////////////////////////////////////////////////////////////////////////
-- running magma_zjacobi
*/
int main( int argc, char** argv)
{
TESTING_INIT();
magma_z_solver_par solver_par;
magma_z_preconditioner precond_par;
solver_par.maxiter = 1000;
solver_par.verbose = 0;
solver_par.num_eigenvalues = 0;
int format = 0;
magma_z_sparse_matrix A, B, B_d;
magma_z_vector x, b;
B.blocksize = 8;
B.alignment = 8;
int scale = 0;
magma_scale_t scaling = Magma_NOSCALE;
magmaDoubleComplex one = MAGMA_Z_MAKE(1.0, 0.0);
magmaDoubleComplex zero = MAGMA_Z_MAKE(0.0, 0.0);
B.storage_type = Magma_CSR;
int i;
for( i = 1; i < argc; ++i ) {
if ( strcmp("--format", argv[i]) == 0 ) {
format = atoi( argv[++i] );
switch( format ) {
case 0: B.storage_type = Magma_CSR; break;
case 1: B.storage_type = Magma_ELL; break;
case 2: B.storage_type = Magma_ELLRT; break;
case 3: B.storage_type = Magma_SELLP; break;
}
}else if ( strcmp("--mscale", argv[i]) == 0 ) {
scale = atoi( argv[++i] );
switch( scale ) {
case 0: scaling = Magma_NOSCALE; break;
case 1: scaling = Magma_UNITDIAG; break;
case 2: scaling = Magma_UNITROW; break;
}
}else if ( strcmp("--blocksize", argv[i]) == 0 ) {
B.blocksize = atoi( argv[++i] );
}else if ( strcmp("--alignment", argv[i]) == 0 ) {
B.alignment = atoi( argv[++i] );
} else if ( strcmp("--maxiter", argv[i]) == 0 ){ // && i+1< argc ) {
solver_par.maxiter = atoi( argv[++i] );
}
else
break;
}
printf( "\n# usage: ./run_zjacobi"
" [ --format %d (0=CSR, 1=ELL 2=ELLRT, 3=SELLP)"
" [ --blocksize %d --alignment %d ]"
" --mscale %d (0=no, 1=unitdiag, 2=unitrownrm)"
" --maxiter %d ]"
" matrices \n\n", format, (int) B.blocksize, (int) B.alignment,
(int) scale,
(int) solver_par.maxiter);
magma_zsolverinfo_init( &solver_par, &precond_par );
while( i < argc ){
magma_z_csr_mtx( &A, argv[i] );
printf( "\n# matrix info: %d-by-%d with %d nonzeros\n\n",
(int) A.num_rows,(int) A.num_cols,(int) A.nnz );
// scale matrix
magma_zmscale( &A, scaling );
magma_z_mconvert( A, &B, Magma_CSR, B.storage_type );
magma_z_mtransfer( B, &B_d, Magma_CPU, Magma_DEV );
// vectors and initial guess
magma_z_vinit( &b, Magma_DEV, A.num_cols, one );
magma_z_vinit( &x, Magma_DEV, A.num_cols, one );
magma_z_spmv( one, B_d, x, zero, b ); // b = A x
magma_z_vfree(&x);
magma_z_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_zjacobi( B_d, b, &x, &solver_par );
magma_zsolverinfo( &solver_par, &precond_par );
magma_z_mfree(&B_d);
magma_z_mfree(&B);
magma_z_mfree(&A);
magma_z_vfree(&x);
magma_z_vfree(&b);
i++;
}
magma_zsolverinfo_free( &solver_par, &precond_par );
TESTING_FINALIZE();
return 0;
}
extern "C" magma_int_t
magma_z_solver(
magma_z_matrix A, magma_z_matrix b,
magma_z_matrix *x, magma_zopts *zopts,
magma_queue_t queue )
{
magma_int_t info = 0;
// make sure RHS is a dense matrix
if ( b.storage_type != Magma_DENSE ) {
printf( "error: sparse RHS not yet supported.\n" );
return MAGMA_ERR_NOT_SUPPORTED;
}
if( b.num_cols == 1 ){
switch( zopts->solver_par.solver ) {
case Magma_CG:
CHECK( magma_zcg_res( A, b, x, &zopts->solver_par, queue )); break;
case Magma_BICG:
CHECK( magma_zbicg( A, b, x, &zopts->solver_par, queue )); break;
case Magma_PBICG:
CHECK( magma_zpbicg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_CGMERGE:
CHECK( magma_zcg_merge( A, b, x, &zopts->solver_par, queue )); break;
case Magma_PCG:
CHECK( magma_zpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_PCGMERGE:
CHECK( magma_zpcg_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_BICGSTAB:
CHECK( magma_zbicgstab( A, b, x, &zopts->solver_par, queue )); break;
case Magma_BICGSTABMERGE:
CHECK( magma_zbicgstab_merge( A, b, x, &zopts->solver_par, queue )); break;
case Magma_PBICGSTABMERGE:
CHECK( magma_zpbicgstab_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_PBICGSTAB:
CHECK( magma_zpbicgstab( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_GMRES:
CHECK( magma_zfgmres( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_PGMRES:
CHECK( magma_zfgmres( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_IDR:
CHECK( magma_zidr( A, b, x, &zopts->solver_par, queue )); break;
case Magma_IDRMERGE:
CHECK( magma_zidr_merge( A, b, x, &zopts->solver_par, queue )); break;
//CHECK( magma_zidr_strms( A, b, x, &zopts->solver_par, queue )); break;
case Magma_PIDR:
CHECK( magma_zpidr( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_PIDRMERGE:
//CHECK( magma_zpidr_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
CHECK( magma_zpidr_strms( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_LOBPCG:
CHECK( magma_zlobpcg( A, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_ITERREF:
CHECK( magma_ziterref( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_JACOBI:
CHECK( magma_zjacobi( A, b, x, &zopts->solver_par, queue )); break;
case Magma_BAITER:
CHECK( magma_zbaiter( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break;
case Magma_BAITERO:
CHECK( magma_zbaiter_overlap( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_CGS:
CHECK( magma_zcgs( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_CGSMERGE:
CHECK( magma_zcgs_merge( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_PCGS:
CHECK( magma_zpcgs( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break;
case Magma_PCGSMERGE:
CHECK( magma_zpcgs_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break;
case Magma_TFQMR:
CHECK( magma_ztfqmr( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_PTFQMR:
CHECK( magma_zptfqmr( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break;
case Magma_TFQMRMERGE:
CHECK( magma_ztfqmr_merge( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_PTFQMRMERGE:
CHECK( magma_zptfqmr_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break;
case Magma_QMR:
CHECK( magma_zqmr( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_LSQR:
CHECK( magma_zlsqr( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break;
case Magma_QMRMERGE:
CHECK( magma_zqmr_merge( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_BOMBARD:
CHECK( magma_zbombard( A, b, x, &zopts->solver_par, queue ) ); break;
case Magma_BOMBARDMERGE:
CHECK( magma_zbombard_merge( A, b, x, &zopts->solver_par, queue ) ); break;
default:
printf("error: solver class not supported.\n"); break;
}
}
else {
switch( zopts->solver_par.solver ) {
case Magma_CG:
CHECK( magma_zbpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_PCG:
CHECK( magma_zbpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break;
case Magma_LOBPCG:
CHECK( magma_zlobpcg( A, &zopts->solver_par, &zopts->precond_par, queue )); break;
default:
printf("error: only 1 RHS supported for this solver class.\n"); break;
}
}
cleanup:
return info;
}
