/*! \fn free memory for linear system solver Lis
*
*/
int
freeLisData(void **voiddata)
{
DATA_LIS* data = (DATA_LIS*) *voiddata;
lis_matrix_destroy(data->A);
lis_vector_destroy(data->b);
lis_vector_destroy(data->x);
lis_solver_destroy(data->solver);
free(data->work);
return 0;
}
LisMatrix::~LisMatrix()
{
int ierr = lis_matrix_destroy(_AA);
checkLisError(ierr);
ierr = lis_vector_destroy(_diag);
checkLisError(ierr);
}
LIS_INT lis_esolver_destroy(LIS_ESOLVER esolver)
{
LIS_INT i,ss;
LIS_DEBUG_FUNC_IN;
if( esolver )
{
lis_esolver_work_destroy(esolver);
if( esolver->rhistory ) lis_free(esolver->rhistory);
if( esolver->evalue ) lis_free(esolver->evalue);
if( esolver->resid ) lis_free(esolver->resid);
if( esolver->iter) lis_free(esolver->iter);
if( esolver->iter2) lis_free(esolver->iter2);
if( esolver->evector )
{
if ( esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_LI || esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_AI || esolver->options[LIS_EOPTIONS_ESOLVER] == LIS_ESOLVER_SI )
{
ss=esolver->options[LIS_EOPTIONS_SUBSPACE];
for(i=0;i<ss+2;i++) lis_vector_destroy(esolver->evector[i]);
}
lis_free(esolver->evector);
}
lis_free(esolver);
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
void lis_vector_destroy_f(LIS_VECTOR_F *vec, LIS_INT *ierr)
{
LIS_DEBUG_FUNC_IN;
*ierr = lis_vector_destroy((LIS_VECTOR)LIS_V2P(vec));
if( *ierr ) return;
LIS_DEBUG_FUNC_OUT;
return;
}
LisMatrix::~LisMatrix()
{
int ierr = 0;
if (_use_external_arrays)
ierr = lis_matrix_unset(_AA);
ierr = lis_matrix_destroy(_AA);
checkLisError(ierr);
ierr = lis_vector_destroy(_diag);
checkLisError(ierr);
}
LIS_INT lis_precon_create_adds(LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT i,j;
LIS_INT precon_type,worklen;
LIS_INT err;
LIS_VECTOR *work;
LIS_DEBUG_FUNC_IN;
precon_type = solver->options[LIS_OPTIONS_PRECON];
worklen = 2;
work = (LIS_VECTOR *)lis_malloc( worklen*sizeof(LIS_VECTOR),"lis_precon_create_adds::work" );
if( work==NULL )
{
LIS_SETERR_MEM(worklen*sizeof(LIS_VECTOR));
return LIS_OUT_OF_MEMORY;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicate(solver->A,&work[i]);
if( err ) break;
}
}
else
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,solver->A,&work[i]);
if( err ) break;
}
}
if( i<worklen )
{
for(j=0;j<i;j++) lis_vector_destroy(work[j]);
lis_free(work);
return err;
}
precon->worklen = worklen;
precon->work = work;
err = lis_precon_create_xxx[precon_type](solver,precon);
if( err )
{
lis_precon_destroy(precon);
return err;
}
precon->A = solver->A;
precon->is_copy = LIS_FALSE;
LIS_DEBUG_FUNC_OUT;
return err;
}
LIS_INT lis_output_matrix(LIS_MATRIX A, LIS_INT format, char *path)
{
LIS_INT err;
LIS_MATRIX B;
LIS_VECTOR b,x;
LIS_DEBUG_FUNC_IN;
#ifdef USE_MPI
MPI_Barrier(A->comm);
#endif
err = lis_matrix_check(A,LIS_MATRIX_CHECK_ALL);
if( err ) return err;
err = lis_vector_create(LIS_COMM_WORLD,&b);
err = lis_vector_create(LIS_COMM_WORLD,&x);
if( format==LIS_FMT_MM || format==LIS_FMT_MMB )
{
switch( A->matrix_type )
{
case LIS_MATRIX_CSR:
err = lis_output_mm_csr(A,b,x,format,path);
break;
default:
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
lis_matrix_set_type(B,LIS_MATRIX_CSR);
err = lis_matrix_convert(A,B);
if( err ) return err;
err = lis_output_mm_csr(B,b,x,format,path);
lis_matrix_destroy(B);
break;
}
}
err = lis_vector_destroy(b);
err = lis_vector_destroy(x);
LIS_DEBUG_FUNC_OUT;
return err;
}
LIS_INT lis_precon_destroy(LIS_PRECON precon)
{
LIS_INT i;
LIS_DEBUG_FUNC_IN;
if( precon )
{
if( precon->is_copy ) lis_matrix_destroy(precon->A);
lis_vector_destroy(precon->Pb);
lis_vector_destroy(precon->D);
lis_vector_destroy(precon->temp);
lis_matrix_ilu_destroy(precon->L);
lis_matrix_ilu_destroy(precon->U);
lis_matrix_diag_destroy(precon->WD);
if( precon->solver )
{
lis_vector_destroy(precon->solver->x);
lis_precon_destroy(precon->solver->precon);
lis_solver_destroy(precon->solver);
}
#if defined(USE_SAAMG)
lis_commtable_destroy(precon->commtable);
if( precon->precon_type==LIS_PRECON_TYPE_SAAMG )
{
(*(void (*)())f_clear_matrix_ptr)(&precon->level_num);
}
#endif
if( precon->work )
{
for(i=0;i<precon->worklen;i++)
{
lis_vector_destroy(precon->work[i]);
}
lis_free(precon->work);
}
lis_free(precon);
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_gmres_malloc_work(LIS_SOLVER solver)
{
LIS_VECTOR *work;
LIS_INT i,j,restart,worklen,err;
LIS_DEBUG_FUNC_IN;
restart = solver->options[LIS_OPTIONS_RESTART];
worklen = NWORK + (restart+1);
work = (LIS_VECTOR *)lis_malloc( worklen*sizeof(LIS_VECTOR),"lis_gmres_malloc_work::work" );
if( work==NULL )
{
LIS_SETERR_MEM(worklen*sizeof(LIS_VECTOR));
return LIS_ERR_OUT_OF_MEMORY;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
for(i=1;i<worklen;i++)
{
err = lis_vector_duplicate(solver->A,&work[i]);
if( err ) break;
}
}
else
{
for(i=1;i<worklen;i++)
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,solver->A,&work[i]);
if( err ) break;
memset(work[i]->value_lo,0,solver->A->np*sizeof(LIS_SCALAR));
}
}
if( i<worklen )
{
for(j=1;j<i;j++) lis_vector_destroy(work[j]);
lis_free(work);
return err;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
lis_vector_create(solver->A->comm,&work[0]);
}
else
{
lis_vector_createex(LIS_PRECISION_QUAD,solver->A->comm,&work[0]);
}
lis_vector_set_size(work[0],restart+1,0);
solver->worklen = worklen;
solver->work = work;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_idrs_malloc_work(LIS_SOLVER solver)
{
LIS_VECTOR *work;
LIS_INT i,j,s,worklen,err;
LIS_DEBUG_FUNC_IN;
/*
err = lis_matrix_convert(solver->A,&solver->At,LIS_MATRIX_CCS);
if( err ) return err;
*/
s = solver->options[LIS_OPTIONS_IDRS_RESTART];
worklen = NWORK + 3*s;
work = (LIS_VECTOR *)lis_malloc(
worklen*sizeof(LIS_VECTOR),"lis_idrs_malloc_work::work" );
if( work==NULL )
{
LIS_SETERR_MEM(worklen*sizeof(LIS_VECTOR));
return LIS_ERR_OUT_OF_MEMORY;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicate(solver->A,&work[i]);
if( err ) break;
}
}
else
{
for(i=0;i<worklen;i++)
{
err =
lis_vector_duplicateex(LIS_PRECISION_QUAD,solver->A,&work[i]);
if( err ) break;
memset(work[i]->value_lo,0,solver->A->np*sizeof(LIS_SCALAR));
}
}
if( i<worklen )
{
for(j=0;j<i;j++) lis_vector_destroy(work[j]);
lis_free(work);
return err;
}
solver->worklen = worklen;
solver->work = work;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_vector_reuse(LIS_VECTOR *vec)
{
LIS_INT err,np,precision;
LIS_DEBUG_FUNC_IN;
err = lis_vector_check(*vec,LIS_VECTOR_CHECK_NULL);
if( err ) return err;
np = (*vec)->np;
if( (*vec)->status==LIS_VECTOR_NULL )
{
precision = ((LIS_VECTOR)*vec)->precision;
if( !precision )
{
(*vec)->value = (LIS_SCALAR *)lis_malloc( np*sizeof(LIS_SCALAR),"lis_vector_reuse::vec->value" );
if( NULL==(*vec)->value )
{
LIS_SETERR_MEM(np*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
(*vec)->is_copy = LIS_TRUE;
}
else
{
(*vec)->value = (LIS_SCALAR *)lis_malloc( (2*np+np%2)*sizeof(LIS_SCALAR),"lis_vector_reuse::vec->value" );
if( NULL==(*vec)->value )
{
LIS_SETERR_MEM((2*np+np%2)*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
(*vec)->is_copy = LIS_TRUE;
(*vec)->value_lo = (*vec)->value + np + np%2;
(*vec)->work = (LIS_SCALAR *)lis_malloc( 32*sizeof(LIS_SCALAR),"lis_vector_reuse::vec->work" );
if( NULL==(*vec)->work )
{
LIS_SETERR_MEM(32*sizeof(LIS_SCALAR));
lis_vector_destroy(*vec);
*vec = NULL;
return LIS_OUT_OF_MEMORY;
}
}
}
(*vec)->status = LIS_VECTOR_ASSEMBLED;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_solver_destroy(LIS_SOLVER solver)
{
LIS_DEBUG_FUNC_IN;
if( solver )
{
lis_solver_work_destroy(solver);
lis_vector_destroy(solver->d);
if( solver->At ) lis_matrix_destroy(solver->At);
if( solver->residual ) lis_free(solver->residual);
lis_free(solver);
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_solver_work_destroy(LIS_SOLVER solver)
{
LIS_INT i;
LIS_DEBUG_FUNC_IN;
if( solver && solver->work )
{
for(i=0;i<solver->worklen;i++) lis_vector_destroy(solver->work[i]);
lis_free(solver->work);
solver->work = NULL;
solver->worklen = 0;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_esolver_work_destroy(LIS_ESOLVER esolver)
{
LIS_INT i;
LIS_DEBUG_FUNC_IN;
if( esolver && esolver->work )
{
for(i=0;i<esolver->worklen;i++) lis_vector_destroy(esolver->work[i]);
lis_free(esolver->work);
esolver->work = NULL;
esolver->worklen = 0;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_esi_malloc_work(LIS_ESOLVER esolver)
{
LIS_VECTOR *work;
LIS_INT i,j,worklen,err,ss;
LIS_DEBUG_FUNC_IN;
ss = esolver->options[LIS_EOPTIONS_SUBSPACE];
worklen = NWORK + ss;
work = (LIS_VECTOR *)lis_malloc( worklen*sizeof(LIS_VECTOR),"lis_esi_malloc_work::work" );
if( work==NULL )
{
LIS_SETERR_MEM(worklen*sizeof(LIS_VECTOR));
return LIS_ERR_OUT_OF_MEMORY;
}
if( esolver->eprecision==LIS_PRECISION_DEFAULT )
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicate(esolver->A,&work[i]);
if( err ) break;
}
}
else
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,esolver->A,&work[i]);
if( err ) break;
}
}
if( i<worklen )
{
for(j=0;j<i;j++) lis_vector_destroy(work[j]);
lis_free(work);
return err;
}
esolver->worklen = worklen;
esolver->work = work;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_cgs_malloc_work(LIS_SOLVER solver)
{
LIS_VECTOR *work;
LIS_INT i,j,worklen,err;
LIS_DEBUG_FUNC_IN;
worklen = NWORK;
work = (LIS_VECTOR *)lis_malloc( worklen*sizeof(LIS_VECTOR),"lis_cgs_malloc_work::work" );
if( work==NULL )
{
LIS_SETERR_MEM(worklen*sizeof(LIS_VECTOR));
return LIS_ERR_OUT_OF_MEMORY;
}
if( solver->precision==LIS_PRECISION_DEFAULT )
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicate(solver->A,&work[i]);
if( err ) break;
}
}
else
{
for(i=0;i<worklen;i++)
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,solver->A,&work[i]);
if( err ) break;
memset(work[i]->value_lo,0,solver->A->np*sizeof(LIS_SCALAR));
}
}
if( i<worklen )
{
for(j=0;j<i;j++) lis_vector_destroy(work[j]);
lis_free(work);
return err;
}
solver->worklen = worklen;
solver->work = work;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
int main(int argc, char* argv[])
{
int err;
int nprocs,mtype,my_rank;
int nsol;
LIS_MATRIX A,A0;
LIS_VECTOR x;
LIS_REAL evalue0;
LIS_SCALAR shift, *tmpa;
LIS_ESOLVER esolver;
LIS_SOLVER solver;
LIS_REAL residual;
int iters;
double times;
double itimes,ptimes,p_c_times,p_i_times;
LIS_PRECON precon;
int *ptr,*index;
LIS_SCALAR *value;
int nsolver;
char esolvername[128];
int mode;
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 4 )
{
if( my_rank==0 ) printf("Usage: etest1 matrix_filename solution_filename residual_filename [options]\n");
lis_finalize();
exit(0);
}
if( my_rank==0 )
{
printf("\n");
printf("number of processes = %d\n",nprocs);
}
#ifdef _OPENMP
if( my_rank==0 )
{
printf("max number of threads = %d\n",omp_get_num_procs());
printf("number of threads = %d\n",omp_get_max_threads());
}
#endif
/* create matrix and vectors */
lis_matrix_create(LIS_COMM_WORLD,&A);
lis_input_matrix(A,argv[1]);
lis_vector_duplicate(A,&x);
lis_esolver_create(&esolver);
lis_esolver_set_option("-eprint mem",esolver);
lis_esolver_set_optionC(esolver);
lis_esolve(A, x, &evalue0, esolver);
lis_esolver_get_esolver(esolver,&nsol);
lis_get_esolvername(nsol,esolvername);
lis_esolver_get_residualnorm(esolver, &residual);
lis_esolver_get_iters(esolver, &iters);
lis_esolver_get_timeex(esolver,×,&itimes,&ptimes,&p_c_times,&p_i_times);
if( my_rank==0 ) {
printf("%s: mode number = %d\n", esolvername, esolver->options[LIS_EOPTIONS_MODE]);
printf("%s: eigenvalue = %e\n", esolvername, evalue0);
printf("%s: number of iterations = %d\n",esolvername, iters);
printf("%s: elapsed time = %e sec.\n", esolvername, times);
printf("%s: preconditioner = %e sec.\n", esolvername, ptimes);
printf("%s: matrix creation = %e sec.\n", esolvername, p_c_times);
printf("%s: linear solver = %e sec.\n", esolvername, itimes);
printf("%s: relative residual 2-norm = %e\n\n",esolvername, residual);
}
/* write solution */
lis_output_vector(x,LIS_FMT_MM,argv[2]);
/* write residual */
lis_esolver_output_rhistory(esolver, argv[3]);
lis_esolver_destroy(esolver);
lis_matrix_destroy(A);
lis_vector_destroy(x);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A0,A,B;
LIS_VECTOR x,b,u;
LIS_SOLVER solver;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nsol,rhs,len,i,j,k,jj,kk,p,nrow_p,l,n;
LIS_INT err,iter,iter_double,iter_quad;
LIS_INT *iw,*nrow,*index,*ptr;
LIS_SCALAR *s,t,*value;
double times,itimes,ptimes,p_c_times,p_i_times;
LIS_REAL resid;
char solvername[128];
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
nprocs = int_nprocs;
my_rank = int_my_rank;
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 5 )
{
if( my_rank==0 )
{
printf("Usage: %s matrix_filename rhs_setting solution_filename residual_filename [options]\n", argv[0]);
}
CHKERR(1);
}
len = (LIS_INT)strlen(argv[2]);
if( len==1 )
{
if( argv[2][0]=='0' || argv[2][0]=='1' || argv[2][0]=='2' )
{
rhs = atoi(argv[2]);
}
else
{
rhs = -1;
}
}
else
{
rhs = -1;
}
if( my_rank==0 )
{
printf("\n");
#ifdef _LONGLONG
printf("number of processes = %lld\n",nprocs);
#else
printf("number of processes = %d\n",nprocs);
#endif
}
#ifdef _OPENMP
if( my_rank==0 )
{
#ifdef _LONGLONG
printf("max number of threads = %lld\n",omp_get_num_procs());
printf("number of threads = %lld\n",omp_get_max_threads());
#else
printf("max number of threads = %d\n",omp_get_num_procs());
printf("number of threads = %d\n",omp_get_max_threads());
#endif
}
#endif
/* read matrix and vectors from file */
err = lis_matrix_create(LIS_COMM_WORLD,&A); CHKERR(err);
err = lis_vector_create(LIS_COMM_WORLD,&b); CHKERR(err);
err = lis_vector_create(LIS_COMM_WORLD,&x); CHKERR(err);
err = lis_input(A,b,x,argv[1]);
CHKERR(err);
err = lis_matrix_duplicate(A,&A0);
CHKERR(err);
lis_matrix_set_type(A0,LIS_MATRIX_CSR);
err = lis_matrix_convert(A,A0);
CHKERR(err);
lis_matrix_destroy(A);
A = A0;
err = lis_vector_duplicate(A,&u);
CHKERR(err);
if( lis_vector_is_null(b) )
{
lis_vector_destroy(b);
lis_vector_duplicate(A,&b);
CHKERR(err);
if( rhs==0 )
{
CHKERR(1);
}
else if( rhs==1 )
{
err = lis_vector_set_all(1.0,b);
}
else
{
err = lis_vector_set_all(1.0,u);
lis_matvec(A,u,b);
}
}
if( rhs==-1 )
{
lis_input_vector(b,argv[2]);
}
if( lis_vector_is_null(x) )
{
lis_vector_destroy(x);
err = lis_vector_duplicate(A,&x);
CHKERR(err);
}
err = lis_solver_create(&solver); CHKERR(err);
lis_solver_set_option("-print mem",solver);
lis_solver_set_optionC(solver);
err = lis_solve(A,b,x,solver);
CHKERR(err);
lis_solver_get_itersex(solver,&iter,&iter_double,&iter_quad);
lis_solver_get_timeex(solver,×,&itimes,&ptimes,&p_c_times,&p_i_times);
lis_solver_get_residualnorm(solver,&resid);
lis_solver_get_solver(solver,&nsol);
lis_solver_get_solvername(nsol,solvername);
/* write results */
if( my_rank==0 )
{
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
printf("%s: number of iterations = %lld \n",solvername, iter);
#else
printf("%s: number of iterations = %lld (double = %lld, quad = %lld)\n",solvername,iter, iter_double, iter_quad);
#endif
#else
#ifdef _LONG__DOUBLE
printf("%s: number of iterations = %d \n",solvername, iter);
#else
printf("%s: number of iterations = %d (double = %d, quad = %d)\n",solvername,iter, iter_double, iter_quad);
#endif
#endif
printf("%s: elapsed time = %e sec.\n",solvername,times);
printf("%s: preconditioner = %e sec.\n",solvername, ptimes);
printf("%s: matrix creation = %e sec.\n",solvername, p_c_times);
printf("%s: linear solver = %e sec.\n",solvername, itimes);
#ifdef _LONG__DOUBLE
printf("%s: relative residual 2-norm = %Le\n\n",solvername,resid);
#else
printf("%s: relative residual 2-norm = %e\n\n",solvername,resid);
#endif
}
/* write solution */
lis_output_vector(x,LIS_FMT_MM,argv[3]);
/* write residual */
lis_solver_output_rhistory(solver, argv[4]);
lis_solver_destroy(solver);
lis_vector_destroy(x);
lis_vector_destroy(u);
lis_vector_destroy(b);
lis_matrix_destroy(A);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LisVector::~LisVector()
{
lis_vector_destroy(_vec);
}
LIS_INT lis_vector_duplicateex(LIS_INT precision, void *A, LIS_VECTOR *vout)
{
LIS_INT np,pad;
LIS_INT nprocs;
LIS_INT i;
#ifdef USE_MPI
LIS_INT *ranges;
#endif
LIS_SCALAR *value;
LIS_DEBUG_FUNC_IN;
if( ((LIS_VECTOR)A)->label!=LIS_LABEL_VECTOR && ((LIS_VECTOR)A)->label!=LIS_LABEL_MATRIX)
{
LIS_SETERR(LIS_ERR_ILL_ARG, "Second argument is not LIS_VECTOR or LIS_MATRIX\n");
return LIS_ERR_ILL_ARG;
}
nprocs = ((LIS_VECTOR)A)->nprocs;
np = ((LIS_VECTOR)A)->np;
pad = ((LIS_VECTOR)A)->pad;
*vout = NULL;
*vout = (LIS_VECTOR)lis_malloc( sizeof(struct LIS_VECTOR_STRUCT),"lis_vector_duplicateex::vout" );
if( NULL==*vout )
{
LIS_SETERR_MEM(sizeof(struct LIS_VECTOR_STRUCT));
return LIS_OUT_OF_MEMORY;
}
lis_vector_init(vout);
if( !precision )
{
value = (LIS_SCALAR *)lis_malloc( (np+pad)*sizeof(LIS_SCALAR),"lis_vector_duplicateex::value" );
if( NULL==value )
{
LIS_SETERR_MEM((np+pad)*sizeof(LIS_SCALAR));
lis_vector_destroy(*vout);
*vout = NULL;
return LIS_OUT_OF_MEMORY;
}
(*vout)->value = value;
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<np+pad;i++)
{
(*vout)->value[i] = 0.0;
}
}
else
{
value = (LIS_SCALAR *)lis_malloc( (2*(np+pad) + (np+pad)%2)*sizeof(LIS_SCALAR),"lis_vector_duplicateex::value" );
if( NULL==value )
{
LIS_SETERR_MEM((2*(np+pad) + (np+pad)%2)*sizeof(LIS_SCALAR));
lis_vector_destroy(*vout);
*vout = NULL;
return LIS_OUT_OF_MEMORY;
}
(*vout)->value = value;
(*vout)->value_lo = value + np+pad + (np+pad)%2;
(*vout)->work = (LIS_SCALAR *)lis_malloc( 32*sizeof(LIS_SCALAR),"lis_vector_duplicateex::vout->work" );
if( NULL==(*vout)->work )
{
LIS_SETERR_MEM(32*sizeof(LIS_SCALAR));
lis_vector_destroy(*vout);
*vout = NULL;
return LIS_OUT_OF_MEMORY;
}
#ifdef USE_VEC_COMP
#pragma cdir nodep
#endif
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<np+pad;i++)
{
(*vout)->value[i] = 0.0;
(*vout)->value_lo[i] = 0.0;
}
}
#ifdef USE_MPI
ranges = (LIS_INT *)lis_malloc( (nprocs+1)*sizeof(LIS_INT),"lis_vector_duplicateex::ranges" );
if( ranges==NULL )
{
LIS_SETERR_MEM((nprocs+1)*sizeof(LIS_INT));
lis_vector_destroy(*vout);
*vout = NULL;
return LIS_OUT_OF_MEMORY;
}
for(i=0;i<nprocs+1;i++) ranges[i] = ((LIS_VECTOR)A)->ranges[i];
(*vout)->ranges = ranges;
#else
(*vout)->ranges = NULL;
#endif
(*vout)->is_copy = LIS_TRUE;
(*vout)->status = LIS_VECTOR_ASSEMBLED;
(*vout)->precision = precision;
(*vout)->n = ((LIS_VECTOR)A)->n;
(*vout)->gn = ((LIS_VECTOR)A)->gn;
(*vout)->np = ((LIS_VECTOR)A)->np;
(*vout)->pad = ((LIS_VECTOR)A)->pad;
(*vout)->comm = ((LIS_VECTOR)A)->comm;
(*vout)->my_rank = ((LIS_VECTOR)A)->my_rank;
(*vout)->nprocs = ((LIS_VECTOR)A)->nprocs;
(*vout)->is = ((LIS_VECTOR)A)->is;
(*vout)->ie = ((LIS_VECTOR)A)->ie;
(*vout)->origin = ((LIS_VECTOR)A)->origin;
(*vout)->is_destroy = ((LIS_VECTOR)A)->is_destroy;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A;
LIS_VECTOR x,b,u;
LIS_SOLVER solver;
LIS_INT k,n,gn,ii,jj;
LIS_INT is,ie;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nsol;
LIS_INT err,iter,iter_double,iter_quad;
double time,itime,ptime,p_c_time,p_i_time;
LIS_REAL resid;
char solvername[128];
LIS_INT *ptr,*index;
LIS_SCALAR *value,gamma;
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
nprocs = int_nprocs;
my_rank = int_my_rank;
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 3 )
{
if( my_rank==0 )
{
printf("Usage: %s n gamma [options]\n", argv[0]);
}
CHKERR(1);
}
gn = atoi(argv[1]);
gamma = atof(argv[2]);
if( gn<=0 )
{
#ifdef _LONGLONG
if( my_rank==0 ) printf("n=%lld <=0 \n",gn);
#else
if( my_rank==0 ) printf("n=%d <=0 \n",gn);
#endif
CHKERR(1);
}
if( my_rank==0 )
{
printf("\n");
#ifdef _LONGLONG
printf("number of processes = %lld\n",nprocs);
#else
printf("number of processes = %d\n",nprocs);
#endif
}
#ifdef _OPENMP
if( my_rank==0 )
{
#ifdef _LONGLONG
printf("max number of threads = %lld\n",omp_get_num_procs());
printf("number of threads = %lld\n",omp_get_max_threads());
#else
printf("max number of threads = %d\n",omp_get_num_procs());
printf("number of threads = %d\n",omp_get_max_threads());
#endif
}
#endif
if(my_rank==0)
{
#ifdef _LONGLONG
printf("n = %lld, gamma = %f\n\n",gn,gamma);
#else
printf("n = %d, gamma = %f\n\n",gn,gamma);
#endif
}
/* create matrix and vectors */
err = lis_matrix_create(LIS_COMM_WORLD,&A); CHKERR(err);
err = lis_matrix_set_size(A,0,gn); CHKERR(err);
err = lis_matrix_get_size(A,&n,&gn); CHKERR(err);
err = lis_matrix_malloc_csr(n,3*n,&ptr,&index,&value); CHKERR(err);
err = lis_matrix_get_range(A,&is,&ie); CHKERR(err);
k = 0;
ptr[0] = 0;
for(ii=is;ii<ie;ii++)
{
if( ii>1 ) { jj = ii - 2; index[k] = jj; value[k++] = gamma;}
if( ii<gn-1 ) { jj = ii + 1; index[k] = jj; value[k++] = 1.0;}
index[k] = ii; value[k++] = 2.0;
ptr[ii-is+1] = k;
}
err = lis_matrix_set_csr(ptr[ie-is],ptr,index,value,A); CHKERR(err);
err = lis_matrix_assemble(A); CHKERR(err);
err = lis_vector_duplicate(A,&u); CHKERR(err);
err = lis_vector_duplicate(u,&b); CHKERR(err);
err = lis_vector_duplicate(u,&x); CHKERR(err);
err = lis_vector_set_all(1.0,u);
lis_matvec(A,u,b);
err = lis_solver_create(&solver); CHKERR(err);
lis_solver_set_option("-print mem",solver);
lis_solver_set_optionC(solver);
err = lis_solve(A,b,x,solver); CHKERR(err);
lis_solver_get_iterex(solver,&iter,&iter_double,&iter_quad);
lis_solver_get_timeex(solver,&time,&itime,&ptime,&p_c_time,&p_i_time);
lis_solver_get_residualnorm(solver,&resid);
lis_solver_get_solver(solver,&nsol);
lis_solver_get_solvername(nsol,solvername);
if( my_rank==0 )
{
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
printf("%s: number of iterations = %lld \n",solvername, iter);
#else
printf("%s: number of iterations = %lld (double = %lld, quad = %lld)\n",solvername,iter, iter_double, iter_quad);
#endif
#else
#ifdef _LONG__DOUBLE
printf("%s: number of iterations = %d \n",solvername, iter);
#else
printf("%s: number of iterations = %d (double = %d, quad = %d)\n",solvername,iter, iter_double, iter_quad);
#endif
#endif
printf("%s: elapsed time = %e sec.\n",solvername,time);
printf("%s: preconditioner = %e sec.\n",solvername, ptime);
printf("%s: matrix creation = %e sec.\n",solvername, p_c_time);
printf("%s: linear solver = %e sec.\n",solvername, itime);
#ifdef _LONG__DOUBLE
printf("%s: relative residual = %Le\n\n",solvername,resid);
#else
printf("%s: relative residual = %e\n\n",solvername,resid);
#endif
}
lis_solver_destroy(solver);
lis_matrix_destroy(A);
lis_vector_destroy(b);
lis_vector_destroy(x);
lis_vector_destroy(u);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_INT i,n,gn,is,ie;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nesol;
LIS_MATRIX A;
LIS_VECTOR x;
LIS_REAL evalue0;
LIS_ESOLVER esolver;
LIS_REAL residual;
LIS_INT iter;
double time;
double itime,ptime,p_c_time,p_i_time;
char esolvername[128];
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
nprocs = int_nprocs;
my_rank = int_my_rank;
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 2 )
{
if( my_rank==0 )
{
printf("Usage: %s n [eoptions]\n", argv[0]);
}
CHKERR(1);
}
if( my_rank==0 )
{
printf("\n");
printf("number of processes = %d\n",nprocs);
}
#ifdef _OPENMP
if( my_rank==0 )
{
#ifdef _LONG__LONG
printf("max number of threads = %lld\n",omp_get_num_procs());
printf("number of threads = %lld\n",omp_get_max_threads());
#else
printf("max number of threads = %d\n",omp_get_num_procs());
printf("number of threads = %d\n",omp_get_max_threads());
#endif
}
#endif
/* generate coefficient matrix for one dimensional Poisson equation */
n = atoi(argv[1]);
lis_matrix_create(LIS_COMM_WORLD,&A);
lis_matrix_set_size(A,0,n);
lis_matrix_get_size(A,&n,&gn);
lis_matrix_get_range(A,&is,&ie);
for(i=is;i<ie;i++)
{
if( i>0 ) lis_matrix_set_value(LIS_INS_VALUE,i,i-1,-1.0,A);
if( i<gn-1 ) lis_matrix_set_value(LIS_INS_VALUE,i,i+1,-1.0,A);
lis_matrix_set_value(LIS_INS_VALUE,i,i,2.0,A);
}
lis_matrix_set_type(A,LIS_MATRIX_CSR);
lis_matrix_assemble(A);
lis_vector_duplicate(A,&x);
lis_esolver_create(&esolver);
lis_esolver_set_option("-eprint mem",esolver);
lis_esolver_set_optionC(esolver);
lis_esolve(A, x, &evalue0, esolver);
lis_esolver_get_esolver(esolver,&nesol);
lis_esolver_get_esolvername(nesol,esolvername);
lis_esolver_get_residualnorm(esolver, &residual);
lis_esolver_get_iter(esolver, &iter);
lis_esolver_get_timeex(esolver,&time,&itime,&ptime,&p_c_time,&p_i_time);
if( my_rank==0 ) {
printf("%s: mode number = %d\n", esolvername, 0);
#ifdef _LONG__DOUBLE
printf("%s: eigenvalue = %Le\n", esolvername, evalue0);
#else
printf("%s: eigenvalue = %e\n", esolvername, evalue0);
#endif
#ifdef _LONG__LONG
printf("%s: number of iterations = %lld\n",esolvername, iter);
#else
printf("%s: number of iterations = %d\n",esolvername, iter);
#endif
printf("%s: elapsed time = %e sec.\n", esolvername, time);
printf("%s: preconditioner = %e sec.\n", esolvername, ptime);
printf("%s: matrix creation = %e sec.\n", esolvername, p_c_time);
printf("%s: linear solver = %e sec.\n", esolvername, itime);
#ifdef _LONG__DOUBLE
printf("%s: relative residual = %Le\n\n",esolvername, residual);
#else
printf("%s: relative residual = %e\n\n",esolvername, residual);
#endif
}
/*
lis_vector_nrm2(x, &xnrm2);
lis_vector_scale((1/xnrm2*sqrt(n)), x);
lis_vector_print(x);
*/
/*
lis_vector_create(LIS_COMM_WORLD,&y);
lis_matrix_create(LIS_COMM_WORLD,&B);
lis_esolver_get_evalues(esolver,y);
lis_esolver_get_evectors(esolver,B);
lis_output_vector(y,LIS_FMT_MM,"evalues.out");
lis_output_matrix(B,LIS_FMT_MM,"evectors.out");
lis_vector_destroy(y);
lis_matrix_destroy(B);
*/
lis_esolver_destroy(esolver);
lis_matrix_destroy(A);
lis_vector_destroy(x);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nsol;
LIS_MATRIX A,B;
LIS_VECTOR x,y,z,w;
LIS_SCALAR evalue0;
LIS_ESOLVER esolver;
LIS_REAL residual;
LIS_INT iter;
double time;
double itime,ptime,p_c_time,p_i_time;
char esolvername[128];
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
nprocs = int_nprocs;
my_rank = int_my_rank;
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 6 )
{
if( my_rank==0 )
{
printf("Usage: %s matrix_filename evalues_filename evectors_filename residuals_filename iters_filename [options]\n", argv[0]);
}
CHKERR(1);
}
if( my_rank==0 )
{
printf("\n");
printf("number of processes = %d\n",nprocs);
}
#ifdef _OPENMP
if( my_rank==0 )
{
printf("max number of threads = %d\n",omp_get_num_procs());
printf("number of threads = %d\n",omp_get_max_threads());
}
#endif
/* create matrix and vectors */
lis_matrix_create(LIS_COMM_WORLD,&A);
lis_input_matrix(A,argv[1]);
lis_vector_duplicate(A,&x);
lis_esolver_create(&esolver);
lis_esolver_set_option("-e si -ss 1 -eprint mem",esolver);
lis_esolver_set_optionC(esolver);
lis_esolve(A, x, &evalue0, esolver);
lis_esolver_get_esolver(esolver,&nsol);
lis_esolver_get_esolvername(nsol,esolvername);
lis_esolver_get_residualnorm(esolver, &residual);
lis_esolver_get_iter(esolver, &iter);
lis_esolver_get_timeex(esolver,&time,&itime,&ptime,&p_c_time,&p_i_time);
if( my_rank==0 ) {
printf("%s: mode number = %d\n", esolvername, 0);
#ifdef _LONG__DOUBLE
printf("%s: eigenvalue = %Le\n", esolvername, evalue0);
#else
printf("%s: eigenvalue = %e\n", esolvername, evalue0);
#endif
#ifdef _LONG__LONG
printf("%s: number of iterations = %lld\n",esolvername, iter);
#else
printf("%s: number of iterations = %d\n",esolvername, iter);
#endif
printf("%s: elapsed time = %e sec.\n", esolvername, time);
printf("%s: preconditioner = %e sec.\n", esolvername, ptime);
printf("%s: matrix creation = %e sec.\n", esolvername, p_c_time);
printf("%s: linear solver = %e sec.\n", esolvername, itime);
#ifdef _LONG__DOUBLE
printf("%s: relative residual = %Le\n\n",esolvername, residual);
#else
printf("%s: relative residual = %e\n\n",esolvername, residual);
#endif
}
lis_vector_create(LIS_COMM_WORLD,&y);
lis_vector_create(LIS_COMM_WORLD,&z);
lis_vector_create(LIS_COMM_WORLD,&w);
lis_matrix_create(LIS_COMM_WORLD,&B);
lis_esolver_get_evalues(esolver,y);
lis_esolver_get_residualnorms(esolver,z);
lis_esolver_get_iters(esolver,w);
lis_esolver_get_evectors(esolver,B);
/* write eigenvalues */
lis_output_vector(y,LIS_FMT_MM,argv[2]);
/* write eigenvectors */
lis_output_matrix(B,LIS_FMT_MM,argv[3]);
/* write residual norms */
lis_output_vector(z,LIS_FMT_MM,argv[4]);
/* write numbers of iterations */
lis_output_vector(w,LIS_FMT_MM,argv[5]);
lis_esolver_destroy(esolver);
lis_matrix_destroy(A);
lis_vector_destroy(x);
lis_matrix_destroy(B);
lis_vector_destroy(y);
lis_vector_destroy(z);
lis_vector_destroy(w);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A0,A;
LIS_VECTOR x,b,u;
LIS_SOLVER solver;
LIS_INT m,n,nn,nnz;
LIS_INT i,j,ii,jj,ctr;
LIS_INT is,ie;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nsol;
LIS_INT err,iter,mtype,iter_double,iter_quad;
double time,itime,ptime,p_c_time,p_i_time;
LIS_REAL resid;
char solvername[128];
LIS_INT *ptr,*index;
LIS_SCALAR *value;
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
nprocs = int_nprocs;
my_rank = int_my_rank;
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 6 )
{
if( my_rank==0 )
{
printf("Usage: %s m n matrix_type solution_filename rhistory_filename [options]\n", argv[0]);
}
CHKERR(1);
}
m = atoi(argv[1]);
n = atoi(argv[2]);
mtype = atoi(argv[3]);
if( m<=0 || n<=0 )
{
#ifdef _LONGLONG
if( my_rank==0 ) printf("m=%lld <=0 or n=%lld <=0\n",m,n);
#else
if( my_rank==0 ) printf("m=%d <=0 or n=%d <=0\n",m,n);
#endif
CHKERR(1);
}
if( my_rank==0 )
{
printf("\n");
#ifdef _LONGLONG
printf("number of processes = %lld\n",nprocs);
#else
printf("number of processes = %d\n",nprocs);
#endif
}
#ifdef _OPENMP
if( my_rank==0 )
{
#ifdef _LONGLONG
printf("max number of threads = %lld\n",omp_get_num_procs());
printf("number of threads = %lld\n",omp_get_max_threads());
#else
printf("max number of threads = %d\n",omp_get_num_procs());
printf("number of threads = %d\n",omp_get_max_threads());
#endif
}
#endif
/* create matrix and vectors */
nn = m*n;
err = lis_matrix_create(LIS_COMM_WORLD,&A);
err = lis_matrix_set_size(A,0,nn);
CHKERR(err);
ptr = (LIS_INT *)malloc((A->n+1)*sizeof(LIS_INT));
if( ptr==NULL ) CHKERR(1);
index = (LIS_INT *)malloc(5*A->n*sizeof(LIS_INT));
if( index==NULL ) CHKERR(1);
value = (LIS_SCALAR *)malloc(5*A->n*sizeof(LIS_SCALAR));
if( value==NULL ) CHKERR(1);
lis_matrix_get_range(A,&is,&ie);
ctr = 0;
for(ii=is;ii<ie;ii++)
{
i = ii/m;
j = ii - i*m;
if( i>0 ) { jj = ii - m; index[ctr] = jj; value[ctr++] = -1.0;}
if( i<n-1 ) { jj = ii + m; index[ctr] = jj; value[ctr++] = -1.0;}
if( j>0 ) { jj = ii - 1; index[ctr] = jj; value[ctr++] = -1.0;}
if( j<m-1 ) { jj = ii + 1; index[ctr] = jj; value[ctr++] = -1.0;}
index[ctr] = ii; value[ctr++] = 4.0;
ptr[ii-is+1] = ctr;
}
ptr[0] = 0;
err = lis_matrix_set_csr(ptr[ie-is],ptr,index,value,A);
CHKERR(err);
err = lis_matrix_assemble(A);
CHKERR(err);
nnz = A->nnz;
#ifdef USE_MPI
MPI_Allreduce(&nnz,&i,1,LIS_MPI_INT,MPI_SUM,A->comm);
nnz = i;
#endif
#ifdef _LONGLONG
if( my_rank==0 ) printf("matrix size = %lld x %lld (%lld nonzero entries)\n\n",nn,nn,nnz);
#else
if( my_rank==0 ) printf("matrix size = %d x %d (%d nonzero entries)\n\n",nn,nn,nnz);
#endif
err = lis_matrix_duplicate(A,&A0);
CHKERR(err);
lis_matrix_set_type(A0,mtype);
err = lis_matrix_convert(A,A0);
CHKERR(err);
lis_matrix_destroy(A);
A = A0;
err = lis_vector_duplicate(A,&u);
CHKERR(err);
err = lis_vector_duplicate(A,&b);
CHKERR(err);
err = lis_vector_duplicate(A,&x);
CHKERR(err);
err = lis_vector_set_all(1.0,u);
lis_matvec(A,u,b);
err = lis_solver_create(&solver); CHKERR(err);
lis_solver_set_option("-print mem",solver);
lis_solver_set_optionC(solver);
err = lis_solve(A,b,x,solver);
CHKERR(err);
lis_solver_get_iterex(solver,&iter,&iter_double,&iter_quad);
lis_solver_get_timeex(solver,&time,&itime,&ptime,&p_c_time,&p_i_time);
lis_solver_get_residualnorm(solver,&resid);
lis_solver_get_solver(solver,&nsol);
lis_solver_get_solvername(nsol,solvername);
if( my_rank==0 )
{
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
printf("%s: number of iterations = %lld \n",solvername, iter);
#else
printf("%s: number of iterations = %lld (double = %lld, quad = %lld)\n",solvername,iter, iter_double, iter_quad);
#endif
#else
#ifdef _LONG__DOUBLE
printf("%s: number of iterations = %d \n",solvername, iter);
#else
printf("%s: number of iterations = %d (double = %d, quad = %d)\n",solvername,iter, iter_double, iter_quad);
#endif
#endif
printf("%s: elapsed time = %e sec.\n",solvername,time);
printf("%s: preconditioner = %e sec.\n",solvername, ptime);
printf("%s: matrix creation = %e sec.\n",solvername, p_c_time);
printf("%s: linear solver = %e sec.\n",solvername, itime);
#ifdef _LONG__DOUBLE
printf("%s: relative residual = %Le\n\n",solvername,resid);
#else
printf("%s: relative residual = %e\n\n",solvername,resid);
#endif
}
/* write solution */
lis_output_vector(x,LIS_FMT_MM,argv[4]);
/* write residual history */
lis_solver_output_rhistory(solver, argv[5]);
lis_solver_destroy(solver);
lis_matrix_destroy(A);
lis_vector_destroy(b);
lis_vector_destroy(x);
lis_vector_destroy(u);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A;
LIS_VECTOR b,x,u;
LIS_SOLVER solver;
LIS_INT my_rank;
#ifdef USE_MPI
int int_nprocs,int_my_rank;
#endif
LIS_INT err,i,n,gn,is,ie,iter;
n = 12;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
my_rank = int_my_rank;
#else
my_rank = 0;
#endif
lis_matrix_create(LIS_COMM_WORLD,&A);
err = lis_matrix_set_size(A,0,n);
CHKERR(err);
lis_matrix_get_size(A,&n,&gn);
lis_matrix_get_range(A,&is,&ie);
for(i=is;i<ie;i++)
{
if( i>0 ) lis_matrix_set_value(LIS_INS_VALUE,i,i-1,-1.0,A);
if( i<gn-1 ) lis_matrix_set_value(LIS_INS_VALUE,i,i+1,-1.0,A);
lis_matrix_set_value(LIS_INS_VALUE,i,i,2.0,A);
}
lis_matrix_set_type(A,LIS_MATRIX_CSR);
lis_matrix_assemble(A);
lis_vector_duplicate(A,&u);
lis_vector_duplicate(A,&b);
lis_vector_duplicate(A,&x);
lis_vector_set_all(1.0,u);
lis_matvec(A,u,b);
lis_solver_create(&solver);
lis_solver_set_option("-print mem",solver);
lis_solver_set_optionC(solver);
lis_solve(A,b,x,solver);
lis_solver_get_iter(solver,&iter);
if (my_rank==0)
{
#ifdef _LONG__LONG
printf("number of iterations = %lld\n",iter);
#else
printf("number of iterations = %d\n",iter);
#endif
printf("\n");
}
lis_vector_print(x);
lis_matrix_destroy(A);
lis_vector_destroy(b);
lis_vector_destroy(x);
lis_vector_destroy(u);
lis_solver_destroy(solver);
lis_finalize();
return 0;
}
LIS_INT lis_solve_kernel(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT nsolver, precon_type, maxiter;
LIS_INT err;
LIS_SCALAR *residual;
LIS_VECTOR xx;
LIS_INT output;
LIS_INT scale;
LIS_INT conv_cond;
LIS_INT precision,is_use_at,storage,block;
LIS_INT i,n,np;
double p_c_times, p_i_times,itimes;
LIS_SCALAR nrm2,tol,tol_w;
LIS_VECTOR t;
LIS_VECTOR bb;
LIS_MATRIX AA,B;
LIS_MATRIX At;
char buf[64];
LIS_DEBUG_FUNC_IN;
nsolver = solver->options[LIS_OPTIONS_SOLVER];
precon_type = solver->options[LIS_OPTIONS_PRECON];
maxiter = solver->options[LIS_OPTIONS_MAXITER];
output = solver->options[LIS_OPTIONS_OUTPUT];
scale = solver->options[LIS_OPTIONS_SCALE];
precision = solver->options[LIS_OPTIONS_PRECISION];
is_use_at = solver->options[LIS_OPTIONS_USE_AT];
storage = solver->options[LIS_OPTIONS_STORAGE];
block = solver->options[LIS_OPTIONS_STORAGE_BLOCK];
conv_cond = solver->options[LIS_OPTIONS_CONV_COND];
tol = solver->params[LIS_PARAMS_RESID-LIS_OPTIONS_LEN];
tol_w = solver->params[LIS_PARAMS_RESID_WEIGHT-LIS_OPTIONS_LEN];
solver->precision = precision;
if( nsolver < 1 || nsolver > LIS_SOLVERS_LEN )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_SOLVER is %d (Set between 1 to %d)\n",nsolver, LIS_SOLVERS_LEN);
return LIS_ERR_ILL_ARG;
}
if( precon_type < 0 || precon_type > precon_register_type )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_PRECON is %d (Set between 0 to %d)\n",precon_type, precon_register_type-1);
return LIS_ERR_ILL_ARG;
}
if( maxiter<0 )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_MAXITER(=%d) is less than 0\n",maxiter);
return LIS_ERR_ILL_ARG;
}
#ifdef USE_MPI
if( precon_type == LIS_PRECON_TYPE_SAAMG && solver->A->nprocs < 2)
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter A->nprocs (=%d) is less than 2 (Set more than 1 when using parallel version of SAAMG)\n",solver->A->nprocs);
return LIS_ERR_ILL_ARG;
}
#endif
#ifdef USE_QUAD_PRECISION
if( precision==LIS_PRECISION_QUAD && lis_solver_execute_quad[nsolver]==NULL )
{
LIS_SETERR1(LIS_ERR_NOT_IMPLEMENTED,"Quad precision solver %s is not implemented\n",lis_solvername[nsolver]);
return LIS_ERR_NOT_IMPLEMENTED;
}
else if( precision==LIS_PRECISION_SWITCH && lis_solver_execute_switch[nsolver]==NULL )
{
LIS_SETERR1(LIS_ERR_NOT_IMPLEMENTED,"Switch solver %s is not implemented\n",lis_solvername[nsolver]);
return LIS_ERR_NOT_IMPLEMENTED;
}
if( solver->options[LIS_OPTIONS_SWITCH_MAXITER]==-1 )
{
solver->options[LIS_OPTIONS_SWITCH_MAXITER] = maxiter;
}
#endif
err = lis_solver_check_params[nsolver](solver);
if( err )
{
solver->retcode = err;
return err;
}
/* end parameter check */
solver->A = A;
solver->b = b;
/* create initial vector */
#ifndef USE_QUAD_PRECISION
err = lis_vector_duplicate(A,&xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
err = lis_vector_duplicate(A,&xx);
}
else
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,A,&xx);
}
#endif
if( err )
{
solver->retcode = err;
return err;
}
if( solver->options[LIS_OPTIONS_INITGUESS_ZEROS] )
{
if( output ) lis_printf(A->comm,"initial vector x = 0\n");
#ifndef USE_QUAD_PRECISION
lis_vector_set_all(0.0,xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
lis_vector_set_all(0.0,xx);
}
else
{
lis_vector_set_allex_nm(0.0,xx);
}
#endif
}
else
{
if( output ) lis_printf(A->comm,"initial vector x = user defined\n");
#ifndef USE_QUAD_PRECISION
lis_vector_copy(x,xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
lis_vector_copy(x,xx);
}
else
{
lis_vector_copyex_nm(x,xx);
}
#endif
}
/* create residual history vector */
if( solver->residual ) lis_free(solver->residual);
residual = (LIS_SCALAR *)lis_malloc((maxiter+2)*sizeof(LIS_SCALAR),"lis_solve::residual");
if( residual==NULL )
{
LIS_SETERR_MEM((maxiter+2)*sizeof(LIS_SCALAR));
lis_vector_destroy(xx);
solver->retcode = err;
return err;
}
residual[0] = 1.0;
n = A->n;
np = A->np;
t = NULL;
At = NULL;
p_c_times = lis_wtime();
if( precon_type==LIS_PRECON_TYPE_IS )
{
if( solver->d==NULL )
{
err = lis_vector_duplicate(A,&solver->d);
if( err )
{
return err;
}
}
if( !A->is_scaled )
{
lis_matrix_scaling(A,b,solver->d,LIS_SCALE_JACOBI);
}
else if( !b->is_scaled )
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
b->value[i] = b->value[i]*solver->d->value[i];
}
}
if( nsolver >= LIS_SOLVER_JACOBI && nsolver <= LIS_SOLVER_SOR )
{
solver->options[LIS_OPTIONS_ISLEVEL] = 0;
}
}
else if( nsolver >= LIS_SOLVER_JACOBI && nsolver <= LIS_SOLVER_SOR && precon_type!=LIS_PRECON_TYPE_NONE )
{
if( solver->d==NULL )
{
err = lis_vector_duplicate(A,&solver->d);
if( err )
{
return err;
}
}
if( !A->is_scaled )
{
lis_matrix_scaling(A,b,solver->d,LIS_SCALE_JACOBI);
}
}
else if( scale )
{
if( storage==LIS_MATRIX_BSR && scale==LIS_SCALE_JACOBI )
{
if( A->matrix_type!=LIS_MATRIX_BSR )
{
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
lis_matrix_set_blocksize(B,block,block,NULL,NULL);
lis_matrix_set_type(B,storage);
err = lis_matrix_convert(A,B);
if( err ) return err;
lis_matrix_storage_destroy(A);
lis_matrix_DLU_destroy(A);
lis_matrix_diag_destroy(A->WD);
if( A->l2g_map ) lis_free( A->l2g_map );
if( A->commtable ) lis_commtable_destroy( A->commtable );
if( A->ranges ) lis_free( A->ranges );
err = lis_matrix_copy_struct(B,A);
if( err ) return err;
lis_free(B);
}
err = lis_matrix_split(A);
if( err ) return err;
err = lis_matrix_diag_duplicate(A->D,&solver->WD);
if( err ) return err;
lis_matrix_diag_copy(A->D,solver->WD);
lis_matrix_diag_inverse(solver->WD);
lis_matrix_bscaling_bsr(A,solver->WD);
lis_vector_duplicate(A,&t);
lis_matrix_diag_matvec(solver->WD,b,t);
lis_vector_copy(t,b);
lis_vector_destroy(t);
t = NULL;
}
else
{
if( solver->d==NULL )
{
err = lis_vector_duplicate(A,&solver->d);
if( err )
{
return err;
}
}
if( scale==LIS_SCALE_JACOBI && nsolver==LIS_SOLVER_CG )
{
scale = LIS_SCALE_SYMM_DIAG;
}
if( !A->is_scaled )
{
lis_matrix_scaling(A,b,solver->d,scale);
}
else if( !b->is_scaled )
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
b->value[i] = b->value[i]*solver->d->value[i];
}
}
}
}
/* precon_type = precon->precon_type;*/
if( precon_type==LIS_PRECON_TYPE_IS )
{
if( nsolver < LIS_SOLVER_JACOBI || nsolver > LIS_SOLVER_SOR )
{
AA = solver->A;
bb = solver->b;
}
else
{
AA = precon->A;
bb = precon->Pb;
}
}
else
{
AA = A;
bb = b;
}
p_c_times = lis_wtime() - p_c_times;
itimes = lis_wtime();
/* Matrix Convert */
solver->A = AA;
solver->b = bb;
err = lis_matrix_convert_self(solver);
if( err )
{
lis_vector_destroy(xx);
lis_solver_work_destroy(solver);
lis_free(residual);
solver->retcode = err;
return err;
}
block = solver->A->bnr;
if( A->my_rank==0 )
{
if( output ) printf("precision : %s\n", lis_precisionname[precision]);
if( output ) printf("solver : %s %d\n", lis_solvername[nsolver],nsolver);
switch( precon_type )
{
case LIS_PRECON_TYPE_ILU:
i = solver->options[LIS_OPTIONS_FILL];
if( A->matrix_type==LIS_MATRIX_BSR || A->matrix_type==LIS_MATRIX_VBR )
{
if( output ) sprintf(buf,"Block %s(%d)",lis_preconname[precon_type],i);
}
else
{
if( output ) sprintf(buf,"%s(%d)",lis_preconname[precon_type],i);
}
break;
default:
if( output ) sprintf(buf,"%s",lis_preconname[precon_type]);
break;
}
if( solver->options[LIS_OPTIONS_ADDS] && precon_type )
{
if( output ) printf("precon : %s + additive schwarz\n", buf);
}
else
{
if( output ) printf("precon : %s\n", buf);
}
}
switch(conv_cond)
{
case LIS_CONV_COND_NRM2_R:
case LIS_CONV_COND_NRM2_B:
if( A->my_rank==0 )
{
if( output ) ("CONV_COND : ||r||_2 <= %6.1e*||r_0||_2\n", tol);
}
break;
case LIS_CONV_COND_NRM1_B:
lis_vector_nrm1(b,&nrm2);
nrm2 = nrm2*tol_w + tol;
if( A->my_rank==0 )
{
if( output ) printf("conv_cond : ||r||_1 <= %6.1e*||b||_1 + %6.1e = %6.1e\n", tol_w,tol,nrm2);
}
break;
}
if( A->my_rank==0 )
{
if( AA->matrix_type==LIS_MATRIX_BSR || AA->matrix_type==LIS_MATRIX_BSC )
{
if( output ) printf("storage : %s(%d x %d)\n", lis_storagename[AA->matrix_type-1],block,block);
}
else
{
if( output ) printf("storage : %s\n", lis_storagename[AA->matrix_type-1]);
}
}
/* create work vector */
err = lis_solver_malloc_work[nsolver](solver);
if( err )
{
lis_vector_destroy(xx);
lis_precon_destroy(precon);
solver->retcode = err;
return err;
}
if( nsolver==LIS_SOLVER_BICG && is_use_at )
{
if( output ) lis_printf(A->comm,"Use At\n");
lis_matrix_duplicate(AA,&At);
lis_matrix_set_type(At,LIS_USE_AT_TYPE[AA->matrix_type]);
lis_matrix_convert(AA,At);
solver->At = At;
}
solver->x = xx;
solver->xx = x;
solver->precon = precon;
solver->residual = residual;
/* execute solver */
#ifndef USE_QUAD_PRECISION
err = lis_solver_execute[nsolver](solver);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
err = lis_solver_execute[nsolver](solver);
}
else if( precision==LIS_PRECISION_QUAD )
{
err = lis_solver_execute_quad[nsolver](solver);
}
else if( precision==LIS_PRECISION_SWITCH )
{
err = lis_solver_execute_switch[nsolver](solver);
}
#endif
solver->retcode = err;
if( scale==LIS_SCALE_SYMM_DIAG && precon_type!=LIS_PRECON_TYPE_IS)
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
x->value[i] = xx->value[i]*solver->d->value[i];
}
}
else
{
#ifndef USE_QUAD_PRECISION
lis_vector_copy(xx,x);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
lis_vector_copy(xx,x);
}
else
{
lis_vector_copyex_mn(xx,x);
}
#endif
}
itimes = lis_wtime() - itimes - solver->ptimes;
p_i_times = solver->ptimes;
solver->ptimes = p_c_times + p_i_times;
solver->p_c_times = p_c_times;
solver->p_i_times = p_i_times;
solver->times = solver->ptimes + itimes;
solver->itimes = itimes;
lis_solver_work_destroy(solver);
lis_vector_duplicate(A,&t);
xx->precision = LIS_PRECISION_DEFAULT;
lis_matvec(A,xx,t);
lis_vector_xpay(b,-1.0,t);
if( scale==LIS_SCALE_SYMM_DIAG && precon_type!=LIS_PRECON_TYPE_IS)
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
t->value[i] = t->value[i]/solver->d->value[i];
}
}
lis_vector_nrm2(t,&nrm2);
/*
solver->resid = nrm2;
*/
if( A->my_rank==0 )
{
if( err )
{
if( output ) printf("lis_solve : %s(code=%d)\n\n",lis_returncode[err],err);
}
else
{
if( output ) printf("lis_solve : normal end\n\n");
}
}
if( precision==LIS_PRECISION_DOUBLE )
{
solver->iter2 = solver->iter;
}
else if( precision==LIS_PRECISION_QUAD )
{
solver->iter2 = 0;
}
lis_vector_destroy(t);
/* lis_vector_destroy(d);*/
lis_vector_destroy(xx);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT main(int argc, char* argv[])
{
LIS_Comm comm;
LIS_INT err;
int nprocs,my_rank;
LIS_INT nesol;
LIS_MATRIX A,B;
LIS_VECTOR x;
LIS_SCALAR evalue0;
LIS_ESOLVER esolver;
LIS_REAL residual;
LIS_INT iter;
double time;
double itime,ptime,p_c_time,p_i_time;
char esolvername[128];
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
comm = LIS_COMM_WORLD;
#ifdef USE_MPI
MPI_Comm_size(comm,&nprocs);
MPI_Comm_rank(comm,&my_rank);
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 5 )
{
lis_printf(comm,"Usage: %s matrix_a_filename matrix_b_filename evector_filename rhistory_filename [options]\n", argv[0]);
CHKERR(1);
}
lis_printf(comm,"\n");
lis_printf(comm,"number of processes = %d\n",nprocs);
#ifdef _OPENMP
lis_printf(comm,"max number of threads = %d\n",omp_get_num_procs());
lis_printf(comm,"number of threads = %d\n",omp_get_max_threads());
#endif
/* create matrix and vectors */
lis_matrix_create(comm,&A);
lis_matrix_create(comm,&B);
lis_printf(comm,"\nmatrix A:\n");
lis_input_matrix(A,argv[1]);
lis_printf(comm,"matrix B:\n");
lis_input_matrix(B,argv[2]);
lis_vector_duplicate(A,&x);
lis_esolver_create(&esolver);
lis_esolver_set_option("-e gii -eprint mem",esolver);
err = lis_esolver_set_optionC(esolver);
CHKERR(err);
err = lis_gesolve(A,B,x,&evalue0,esolver);
CHKERR(err);
lis_esolver_get_esolver(esolver,&nesol);
lis_esolver_get_esolvername(nesol,esolvername);
lis_esolver_get_residualnorm(esolver,&residual);
lis_esolver_get_iter(esolver,&iter);
lis_esolver_get_timeex(esolver,&time,&itime,&ptime,&p_c_time,&p_i_time);
lis_printf(comm,"%s: mode number = %d\n", esolvername, 0);
#ifdef _COMPLEX
lis_printf(comm,"%s: eigenvalue = (%e, %e)\n", esolvername, (double)creal(evalue0), (double)cimag(evalue0));
#else
lis_printf(comm,"%s: eigenvalue = %e\n", esolvername, (double)evalue0);
#endif
lis_printf(comm,"%s: number of iterations = %D\n",esolvername, iter);
lis_printf(comm,"%s: elapsed time = %e sec.\n", esolvername, time);
lis_printf(comm,"%s: preconditioner = %e sec.\n", esolvername, ptime);
lis_printf(comm,"%s: matrix creation = %e sec.\n", esolvername, p_c_time);
lis_printf(comm,"%s: linear solver = %e sec.\n", esolvername, itime);
lis_printf(comm,"%s: relative residual = %e\n\n",esolvername, (double)residual);
/* write eigenvector */
lis_output_vector(x,LIS_FMT_MM,argv[3]);
/* write residual history */
lis_esolver_output_rhistory(esolver,argv[4]);
lis_esolver_destroy(esolver);
lis_matrix_destroy(A);
lis_matrix_destroy(B);
lis_vector_destroy(x);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
/// destructor
LisMPIDiscreteVector::~LisMPIDiscreteVector()
{
lis_vector_destroy(_v);
};
LIS_INT lis_minres(LIS_SOLVER solver)
{
LIS_Comm comm;
LIS_MATRIX A;
LIS_VECTOR b,x;
LIS_VECTOR v1,v2,v3,v4,w0,w1,w2;
LIS_REAL nrm2,tol;
LIS_SCALAR alpha;
LIS_REAL beta2,beta3;
LIS_SCALAR gamma1,gamma2,gamma3;
LIS_SCALAR delta,eta;
LIS_SCALAR sigma1,sigma2,sigma3;
LIS_SCALAR rho1,rho2,rho3;
LIS_REAL r0_euc,r_euc;
LIS_INT iter,maxiter,output;
double time,ptime;
LIS_DEBUG_FUNC_IN;
comm = LIS_COMM_WORLD;
A = solver->A;
b = solver->b;
x = solver->x;
tol = solver->params[LIS_PARAMS_RESID-LIS_OPTIONS_LEN];
maxiter = solver->options[LIS_OPTIONS_MAXITER];
output = solver->options[LIS_OPTIONS_OUTPUT];
ptime = 0.0;
v1 = solver->work[0];
v2 = solver->work[1];
v3 = solver->work[2];
v4 = solver->work[3];
w0 = solver->work[4];
w1 = solver->work[5];
w2 = solver->work[6];
/* Lanczos algorithm */
lis_matvec(A,x,v2);
lis_vector_xpay(b,-1.0,v2);
time = lis_wtime();
lis_psolve(solver,v2,v3);
ptime += lis_wtime()-time;
lis_vector_copy(v3,v2);
/* Compute elements of Hermitian tridiagonal matrix */
lis_vector_nrm2(v2,&r_euc);
eta = beta2 = r0_euc = r_euc;
gamma2 = gamma1 = 1.0;
sigma2 = sigma1 = 0.0;
lis_vector_set_all(0.0,v1);
lis_vector_set_all(0.0,w0);
lis_vector_set_all(0.0,w1);
nrm2 = r_euc / r0_euc;
for(iter=1;iter<=maxiter;iter++)
{
/* Lanczos algorithm */
lis_vector_scale(1.0 / beta2,v2);
lis_matvec(A,v2,v3);
time = lis_wtime();
lis_psolve(solver,v3,v4);
ptime += lis_wtime()-time;
lis_vector_dot(v2,v4,&alpha);
lis_vector_axpy(-alpha,v2,v4);
lis_vector_axpy(-beta2,v1,v4);
lis_vector_nrm2(v4,&beta3);
/* Compute elements of Hermitian tridiagonal matrix */
delta = gamma2 * alpha - gamma1 * sigma2 * beta2;
rho1 = sqrt(delta * delta + beta3 * beta3);
rho2 = sigma2 * alpha + gamma1 * gamma2 * beta2;
rho3 = sigma1 * beta2;
gamma3 = delta / rho1;
sigma3 = beta3 / rho1;
lis_vector_axpyz(-rho3,w0,v2,w2);
lis_vector_axpy(-rho2,w1,w2);
lis_vector_scale(1.0 / rho1,w2);
lis_vector_axpy(gamma3 * eta,w2,x);
/* convergence check */
r_euc *= fabs(sigma3);
nrm2 = r_euc / r0_euc;
if( output )
{
if( output & LIS_PRINT_MEM ) solver->rhistory[iter] = nrm2;
if( output & LIS_PRINT_OUT ) lis_print_rhistory(comm,iter,nrm2);
}
if( nrm2 <= tol )
{
solver->retcode = LIS_SUCCESS;
solver->iter = iter;
solver->resid = nrm2;
solver->ptime = ptime;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
eta *= -sigma3;
lis_vector_copy(v2,v1);
lis_vector_copy(v4,v2);
lis_vector_copy(w1,w0);
lis_vector_copy(w2,w1);
beta2 = beta3;
gamma1 = gamma2;
gamma2 = gamma3;
sigma1 = sigma2;
sigma2 = sigma3;
}
lis_vector_destroy(v1);
lis_vector_destroy(v2);
lis_vector_destroy(v3);
lis_vector_destroy(v4);
lis_vector_destroy(w0);
lis_vector_destroy(w1);
lis_vector_destroy(w2);
solver->retcode = LIS_MAXITER;
solver->iter = iter;
solver->resid = nrm2;
LIS_DEBUG_FUNC_OUT;
return LIS_MAXITER;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A,A0;
LIS_VECTOR b,x;
LIS_SCALAR *value;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nthreads,maxthreads;
LIS_INT gn,nnz,np;
LIS_INT i,j,k,si,sj,sk,ii,jj,ctr;
LIS_INT l,m,n,nn;
LIS_INT is,ie;
LIS_INT err,iter,matrix_type,storage,ss,se;
LIS_INT *ptr,*index;
double time,time2,nnzs,nnzap,nnzt;
LIS_SCALAR val;
double commtime,comptime,flops;
LIS_DEBUG_FUNC_IN;
lis_initialize(&argc, &argv);
#ifdef USE_MPI
MPI_Comm_size(MPI_COMM_WORLD,&int_nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&int_my_rank);
nprocs = int_nprocs;
my_rank = int_my_rank;
#else
nprocs = 1;
my_rank = 0;
#endif
if( argc < 5 )
{
if( my_rank==0 )
{
printf("Usage: %s l m n iter [matrix_type]\n", argv[0]);
}
CHKERR(1);
}
l = atoi(argv[1]);
m = atoi(argv[2]);
n = atoi(argv[3]);
iter = atoi(argv[4]);
if (argv[5] == NULL) {
storage = 0;
}
else {
storage = atoi(argv[5]);
}
if( iter<=0 )
{
#ifdef _LONG__LONG
if( my_rank==0 ) printf("iter=%lld <= 0\n",iter);
#else
if( my_rank==0 ) printf("iter=%d <= 0\n",iter);
#endif
CHKERR(1);
}
if( l<=0 || m<=0 || n<=0 )
{
#ifdef _LONG__LONG
if( my_rank==0 ) printf("l=%lld <=0, m=%lld <=0 or n=%lld <=0\n",l,m,n);
#else
if( my_rank==0 ) printf("l=%d <=0, m=%d <=0 or n=%d <=0\n",l,m,n);
#endif
CHKERR(1);
}
if( storage<0 || storage>11 )
{
#ifdef _LONG__LONG
if( my_rank==0 ) printf("matrix_type=%lld < 0 or matrix_type=%lld > 11\n",storage,storage);
#else
if( my_rank==0 ) printf("matrix_type=%d < 0 or matrix_type=%d > 11\n",storage,storage);
#endif
CHKERR(1);
}
if( my_rank==0 )
{
printf("\n");
#ifdef _LONG__LONG
printf("number of processes = %lld\n",nprocs);
#else
printf("number of processes = %d\n",nprocs);
#endif
}
#ifdef _OPENMP
nthreads = omp_get_num_procs();
maxthreads = omp_get_max_threads();
if( my_rank==0 )
{
#ifdef _LONG__LONG
printf("max number of threads = %lld\n", nthreads);
printf("number of threads = %lld\n", maxthreads);
#else
printf("max number of threads = %d\n", nthreads);
printf("number of threads = %d\n", maxthreads);
#endif
}
#else
nthreads = 1;
maxthreads = 1;
#endif
/* create matrix and vectors */
nn = l*m*n;
err = lis_matrix_create(LIS_COMM_WORLD,&A0);
err = lis_matrix_set_size(A0,0,nn);
CHKERR(err);
ptr = (LIS_INT *)malloc((A0->n+1)*sizeof(LIS_INT));
if( ptr==NULL ) CHKERR(1);
index = (LIS_INT *)malloc(27*A0->n*sizeof(LIS_INT));
if( index==NULL ) CHKERR(1);
value = (LIS_SCALAR *)malloc(27*A0->n*sizeof(LIS_SCALAR));
if( value==NULL ) CHKERR(1);
lis_matrix_get_range(A0,&is,&ie);
ctr = 0;
for(ii=is;ii<ie;ii++)
{
i = ii/(m*n);
j = (ii - i*m*n)/n;
k = ii - i*m*n - j*n;
for(si=-1;si<=1;si++) {
if( i+si>-1 && i+si<l ) {
for(sj=-1;sj<=1;sj++) {
if( j+sj>-1 && j+sj<m ) {
for(sk=-1;sk<=1;sk++) {
if( k+sk>-1 && k+sk<n ) {
jj = ii + si*m*n + sj*n + sk;
index[ctr] = jj;
if( jj==ii ) { value[ctr++] = 26.0;}
else { value[ctr++] = -1.0;}
}
}
}
}
}
}
ptr[ii-is+1] = ctr;
}
ptr[0] = 0;
err = lis_matrix_set_csr(ptr[ie-is],ptr,index,value,A0);
CHKERR(err);
err = lis_matrix_assemble(A0);
CHKERR(err);
n = A0->n;
gn = A0->gn;
nnz = A0->nnz;
np = A0->np-n;
#ifdef USE_MPI
MPI_Allreduce(&nnz,&i,1,LIS_MPI_INT,MPI_SUM,A0->comm);
nnzap = (double)i / (double)nprocs;
nnzt = ((double)nnz -nnzap)*((double)nnz -nnzap);
nnz = i;
MPI_Allreduce(&nnzt,&nnzs,1,MPI_DOUBLE,MPI_SUM,A0->comm);
nnzs = (nnzs / (double)nprocs)/nnzap;
MPI_Allreduce(&np,&i,1,LIS_MPI_INT,MPI_SUM,A0->comm);
np = i;
#endif
if( my_rank==0 )
{
#ifdef _LONG__LONG
printf("matrix size = %lld x %lld (%lld nonzero entries)\n",gn,gn,nnz);
printf("number of iterations = %lld\n\n",iter);
#else
printf("matrix size = %d x %d (%d nonzero entries)\n",gn,gn,nnz);
printf("number of iterations = %d\n\n",iter);
#endif
}
err = lis_vector_duplicate(A0,&x);
if( err ) CHKERR(err);
err = lis_vector_duplicate(A0,&b);
if( err ) CHKERR(err);
lis_matrix_get_range(A0,&is,&ie);
for(i=0;i<n;i++)
{
err = lis_vector_set_value(LIS_INS_VALUE,i+is,1.0,x);
}
for(i=0;i<n;i++)
{
lis_sort_id(A0->ptr[i],A0->ptr[i+1]-1,A0->index,A0->value);
}
/*
MPI version of VBR is not implemented.
DNS is also excluded to reduce memory usage.
*/
if (storage==0)
{
ss = 1;
se = 11;
}
else
{
ss = storage;
se = storage+1;
}
for (matrix_type=ss;matrix_type<se;matrix_type++)
{
if ( nprocs>1 && matrix_type==9 ) continue;
lis_matrix_duplicate(A0,&A);
lis_matrix_set_type(A,matrix_type);
err = lis_matrix_convert(A0,A);
if( err ) CHKERR(err);
comptime = 0.0;
commtime = 0.0;
for(i=0;i<iter;i++)
{
#ifdef USE_MPI
MPI_Barrier(A->comm);
time = lis_wtime();
lis_send_recv(A->commtable,x->value);
commtime += lis_wtime() - time;
#endif
time2 = lis_wtime();
lis_matvec(A,x,b);
comptime += lis_wtime() - time2;
}
lis_vector_nrm2(b,&val);
if( my_rank==0 )
{
flops = 2.0*nnz*iter*1.0e-6 / comptime;
#ifdef USE_MPI
#ifdef _LONG__DOUBLE
#ifdef _LONG__LONG
printf("matrix_type = %2lld (%s), computation = %e sec, %8.3f MFLOPS, communication = %e sec, communication/computation = %3.3f %%, 2-norm = %Le\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,commtime,commtime/comptime*100,val);
#else
printf("matrix_type = %2d (%s), computation = %e sec, %8.3f MFLOPS, communication = %e sec, communication/computation = %3.3f %%, 2-norm = %Le\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,commtime,commtime/comptime*100,val);
#endif
#else
#ifdef _LONG__LONG
printf("matrix_type = %2lld (%s), computation = %e sec, %8.3f MFLOPS, communication = %e sec, communication/computation = %3.3f %%, 2-norm = %e\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,commtime,commtime/comptime*100,val);
#else
printf("matrix_type = %2d (%s), computation = %e sec, %8.3f MFLOPS, communication = %e sec, communication/computation = %3.3f %%, 2-norm = %e\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,commtime,commtime/comptime*100,val);
#endif
#endif
#else
#ifdef _LONG__DOUBLE
#ifdef _LONG__LONG
printf("matrix_type = %2lld (%s), computation = %e sec, %8.3f MFLOPS, 2-norm = %Le\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,val);
#else
printf("matrix_type = %2d (%s), computation = %e sec, %8.3f MFLOPS, 2-norm = %Le\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,val);
#endif
#else
#ifdef _LONG__LONG
printf("matrix_type = %2lld (%s), computation = %e sec, %8.3f MFLOPS, 2-norm = %e\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,val);
#else
printf("matrix_type = %2d (%s), computation = %e sec, %8.3f MFLOPS, 2-norm = %e\n",matrix_type,lis_storagename2[matrix_type-1],comptime,flops,val);
#endif
#endif
#endif
}
lis_matrix_destroy(A);
}
lis_matrix_destroy(A0);
lis_vector_destroy(b);
lis_vector_destroy(x);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}