/* ////////////////////////////////////////////////////////////////////////////
-- running magma_zbaiter
*/
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 scale = 0;
magma_scale_t scaling = Magma_NOSCALE;
magma_z_sparse_matrix A;
magma_z_vector x, b;
magmaDoubleComplex one = MAGMA_Z_MAKE(1.0, 0.0);
magmaDoubleComplex zero = MAGMA_Z_MAKE(0.0, 0.0);
int i;
for( i = 1; i < argc; ++i ) {
if ( strcmp("--maxiter", argv[i]) == 0 ){
solver_par.maxiter = atoi( argv[++i] );
}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
break;
}
printf( "\n# usage: ./run_zbaiter"
" [ "
" --mscale %d (0=no, 1=unitdiag, 2=unitrownrm)"
" --maxiter %d ]"
" matrices \n\n",
(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 initial guess
magma_zmscale( &A, scaling );
magma_z_vinit( &b, Magma_DEV, A.num_cols, one );
magma_z_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_zbaiter( A, b, &x, &solver_par );
magma_zsolverinfo( &solver_par, &precond_par );
magma_z_mfree(&A);
magma_z_vfree(&x);
magma_z_vfree(&b);
i++;
}
magma_zsolverinfo_free( &solver_par, &precond_par );
TESTING_FINALIZE();
return 0;
}
/* ////////////////////////////////////////////////////////////////////////////
-- 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;
}
/* ////////////////////////////////////////////////////////////////////////////
-- running magma_zgmres
*/
int main( int argc, char** argv)
{
TESTING_INIT();
magma_z_solver_par solver_par;
magma_z_preconditioner precond_par;
solver_par.epsilon = 10e-16;
solver_par.maxiter = 1000;
solver_par.restart = 30;
solver_par.num_eigenvalues = 0;
solver_par.ortho = Magma_CGS;
solver_par.verbose = 0;
int format = 0;
int ortho = 0;
int scale = 0;
magma_scale_t scaling = Magma_NOSCALE;
magma_z_sparse_matrix A, B, B_d;
magma_z_vector x, b;
B.blocksize = 8;
B.alignment = 8;
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("--verbose", argv[i]) == 0 ) {
solver_par.verbose = atoi( argv[++i] );
} else if ( strcmp("--ortho", argv[i]) == 0 ) {
ortho = atoi( argv[++i] );
switch( ortho ) {
case 0: solver_par.ortho = Magma_CGS; break;
case 1: solver_par.ortho = Magma_MGS; break;
case 2: solver_par.ortho = Magma_FUSED_CGS; break;
}
} else if ( strcmp("--restart", argv[i]) == 0 ) {
solver_par.restart = atoi( argv[++i] );
} else if ( strcmp("--maxiter", argv[i]) == 0 ) {
solver_par.maxiter = atoi( argv[++i] );
} else if ( strcmp("--tol", argv[i]) == 0 ) {
sscanf( argv[++i], "%lf", &solver_par.epsilon );
} else
break;
}
printf( "\n# usage: ./run_zgmres"
" [ --format %d (0=CSR, 1=ELL 2=ELLRT, 3=SELLP)"
" [ --blocksize %d --alignment %d ]"
" --mscale %d (0=no, 1=unitdiag, 2=unitrownrm)"
" --verbose %d (0=summary, k=details every k iterations)"
" --restart %d --maxiter %d --tol %.2e"
" --ortho %d (0=CGS, 1=MGS, 2=FUSED_CGS) ]"
" matrices \n\n", format, (int) B.blocksize, (int) B.alignment,
(int) scale,
(int) solver_par.verbose,
(int) solver_par.restart, (int) solver_par.maxiter,
solver_par.epsilon, ortho );
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_zgmres( 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;
}
/* ////////////////////////////////////////////////////////////////////////////
-- Debugging file
*/
int main( int argc, char** argv)
{
TESTING_INIT();
magma_z_solver_par solver_par;
magma_z_preconditioner precond_par;
solver_par.epsilon = 10e-16;
solver_par.maxiter = 1000;
solver_par.verbose = 0;
solver_par.restart = 30;
solver_par.num_eigenvalues = 0;
solver_par.ortho = Magma_CGS;
magmaDoubleComplex one = MAGMA_Z_MAKE(1.0, 0.0);
magmaDoubleComplex zero = MAGMA_Z_MAKE(0.0, 0.0);
magma_z_sparse_matrix A, B, B_d;
magma_z_vector x, b;
// generate matrix of desired structure and size
magma_int_t n=100; // size is n*n
magma_int_t nn = n*n;
magma_int_t offdiags = 2;
magma_index_t *diag_offset;
magmaDoubleComplex *diag_vals;
magma_zmalloc_cpu( &diag_vals, offdiags+1 );
magma_index_malloc_cpu( &diag_offset, offdiags+1 );
diag_offset[0] = 0;
diag_offset[1] = 1;
diag_offset[2] = n;
diag_vals[0] = MAGMA_Z_MAKE( 4.1, 0.0 );
diag_vals[1] = MAGMA_Z_MAKE( -1.0, 0.0 );
diag_vals[2] = MAGMA_Z_MAKE( -1.0, 0.0 );
magma_zmgenerator( nn, offdiags, diag_offset, diag_vals, &A );
// convert marix into desired format
B.storage_type = Magma_SELLC;
B.blocksize = 8;
B.alignment = 8;
// scale matrix
magma_zmscale( &A, Magma_UNITDIAG );
magma_z_mconvert( A, &B, Magma_CSR, B.storage_type );
magma_z_mtransfer( B, &B_d, Magma_CPU, Magma_DEV );
// test CG ####################################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// solver
magma_zcg_res( B_d, b, &x, &solver_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test PCG Jacobi ############################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_JACOBI;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test PCG IC ################################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ICC;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test PCG IC ################################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ICC;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpcg( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test BICGSTAB ####################################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// solver
magma_zbicgstab( B_d, b, &x, &solver_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test PBICGSTAB Jacobi ############################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_JACOBI;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpbicgstab( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
/*
// test PBICGSTAB ILU ###############################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ILU;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpbicgstab( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test PBICGSTAB ILU ###############################
// 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);printf("here\n");
magma_z_vinit( &x, Magma_DEV, A.num_cols, zero );
magma_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ILU;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpbicgstab( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test GMRES ####################################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// solver
magma_zgmres( B_d, b, &x, &solver_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
// test PGMRES Jacobi ############################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_JACOBI;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpgmres( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);*/
// test PGMRES ILU ###############################
// 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_zsolverinfo_init( &solver_par, &precond_par );
// Preconditioner
precond_par.solver = Magma_ILU;
magma_z_precondsetup( B_d, b, &precond_par );
// solver
magma_zpgmres( B_d, b, &x, &solver_par, &precond_par );
// solverinfo
magma_zsolverinfo( &solver_par, &precond_par );
if( solver_par.numiter > 150 ){
printf("error: test not passed!\n"); exit(-1);
}
magma_zsolverinfo_free( &solver_par, &precond_par );
magma_z_vfree(&x);
magma_z_vfree(&b);
printf("all tests passed.\n");
magma_z_mfree(&B_d);
magma_z_mfree(&B);
magma_z_mfree(&A);
TESTING_FINALIZE();
return 0;
}
