extern "C" magma_int_t
magma_d_solver(
magma_d_sparse_matrix A, magma_d_vector b,
magma_d_vector *x, magma_dopts *zopts,
magma_queue_t queue )
{
// preconditioner
if ( zopts->solver_par.solver != Magma_ITERREF ) {
magma_d_precondsetup( A, b, &zopts->precond_par, queue );
}
switch( zopts->solver_par.solver ) {
case Magma_CG:
magma_dcg_res( A, b, x, &zopts->solver_par, queue );break;
case Magma_CGMERGE:
magma_dcg_merge( A, b, x, &zopts->solver_par, queue );break;
case Magma_PCG:
magma_dpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue );break;
case Magma_BICGSTAB:
magma_dbicgstab( A, b, x, &zopts->solver_par, queue );break;
case Magma_BICGSTABMERGE:
magma_dbicgstab_merge( A, b, x, &zopts->solver_par, queue );break;
case Magma_PBICGSTAB:
magma_dpbicgstab( A, b, x, &zopts->solver_par, &zopts->precond_par, queue );break;
case Magma_GMRES:
magma_dfgmres( A, b, x, &zopts->solver_par, &zopts->precond_par, queue );break;
case Magma_PGMRES:
magma_dfgmres( A, b, x, &zopts->solver_par, &zopts->precond_par, queue );break;
case Magma_LOBPCG:
magma_dlobpcg( A, &zopts->solver_par, queue );break;
case Magma_ITERREF:
magma_diterref( A, b, x, &zopts->solver_par, &zopts->precond_par, queue );break;
case Magma_JACOBI:
magma_djacobi( A, b, x, &zopts->solver_par, queue );break;
case Magma_BAITER:
magma_dbaiter( A, b, x, &zopts->solver_par, queue );break;
}
return MAGMA_SUCCESS;
}
/* ////////////////////////////////////////////////////////////////////////////
-- running magma_dlobpcg
*/
int main( int argc, char** argv)
{
TESTING_INIT();
magma_d_solver_par solver_par;
solver_par.epsilon = 1e-5;
solver_par.maxiter = 1000;
solver_par.verbose = 0;
solver_par.num_eigenvalues = 32;
solver_par.solver = Magma_LOBPCG;
magma_d_preconditioner precond_par;
precond_par.solver = Magma_JACOBI;
int precond = 0;
int format = 0;
int scale = 0;
magma_scale_t scaling = Magma_NOSCALE;
magma_d_sparse_matrix A, B, dA;
B.blocksize = 8;
B.alignment = 8;
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("--precond", argv[i]) == 0 ) {
format = atoi( argv[++i] );
switch( precond ) {
case 0: precond_par.solver = Magma_JACOBI; 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("--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 if ( strcmp("--eigenvalues", argv[i]) == 0 ) {
solver_par.num_eigenvalues = atoi( argv[++i] );
} else
break;
}
printf( "\n# usage: ./run_dlobpcg"
" [ --format %d (0=CSR, 1=ELL, 2=ELLRT, 4=SELLP)"
" [ --blocksize %d --alignment %d ]"
" --mscale %d (0=no, 1=unitdiag, 2=unitrownrm)"
" --verbose %d (0=summary, k=details every k iterations)"
" --maxiter %d --tol %.2e"
" --preconditioner %d (0=Jacobi) "
" --eigenvalues %d ]"
" matrices \n\n", format, (int) B.blocksize, (int) B.alignment,
(int) scale,
(int) solver_par.verbose,
(int) solver_par.maxiter, solver_par.epsilon, precond,
(int) solver_par.num_eigenvalues);
while( i < argc ){
magma_d_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_dmscale( &A, scaling );
solver_par.ev_length = A.num_cols;
magma_d_sparse_matrix A2;
A2.storage_type = Magma_SELLC;
A2.blocksize = 8;
A2.alignment = 4;
magma_d_mconvert( A, &A2, Magma_CSR, A2.storage_type );
// copy matrix to GPU
magma_d_mtransfer( A2, &dA, Magma_CPU, Magma_DEV);
magma_dsolverinfo_init( &solver_par, &precond_par ); // inside the loop!
// as the matrix size has influence on the EV-length
real_Double_t gpu_time;
// Find the blockSize smallest eigenvalues and corresponding eigen-vectors
gpu_time = magma_wtime();
magma_dlobpcg( dA, &solver_par );
gpu_time = magma_wtime() - gpu_time;
printf("Time (sec) = %7.2f\n", gpu_time);
printf("solver runtime (sec) = %7.2f\n", solver_par.runtime );
magma_dsolverinfo_free( &solver_par, &precond_par );
magma_d_mfree( &dA );
magma_d_mfree( &A2 );
magma_d_mfree( &A );
i++;
}
TESTING_FINALIZE();
return 0;
}
