LIS_INT lis_precon_create_ilut(LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT err;
LIS_MATRIX A,B;
LIS_DEBUG_FUNC_IN;
switch( solver->A->matrix_type )
{
case LIS_MATRIX_CSR:
err = lis_precon_create_ilut_csr(solver,precon);
lis_psolve_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolve_ilut_csr;
lis_psolvet_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolvet_ilut_csr;
break;
default:
A = solver->A;
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;
solver->A = B;
err = lis_precon_create_ilut_csr(solver,precon);
lis_psolve_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolve_ilut_csr;
lis_psolvet_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolvet_ilut_csr;
lis_matrix_destroy(B);
solver->A = A;
break;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LisMatrix::~LisMatrix()
{
int ierr = lis_matrix_destroy(_AA);
checkLisError(ierr);
ierr = lis_vector_destroy(_diag);
checkLisError(ierr);
}
LIS_INT lis_output(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_INT format, char *path)
{
LIS_INT err;
LIS_MATRIX B;
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;
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;
}
}
LIS_DEBUG_FUNC_OUT;
return err;
}
void lis_matrix_destroy_f(LIS_MATRIX_F *Amat, LIS_INT *ierr)
{
LIS_DEBUG_FUNC_IN;
*ierr = lis_matrix_destroy((LIS_MATRIX)LIS_V2P(Amat));
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_ilut(LIS_SOLVER solver, LIS_PRECON precon)
{
#ifdef ENABLE_BSR
LIS_INT storage,block;
#endif
LIS_INT err;
LIS_MATRIX A,B;
LIS_DEBUG_FUNC_IN;
#ifdef ENABLE_BSR
storage = solver->options[LIS_OPTIONS_STORAGE];
block = solver->options[LIS_OPTIONS_STORAGE_BLOCK];
if( solver->A->matrix_type!=LIS_MATRIX_BSR && storage==LIS_MATRIX_BSR )
{
err = lis_matrix_convert_self(solver);
if( err ) return err;
}
#endif
switch( solver->A->matrix_type )
{
case LIS_MATRIX_CSR:
err = lis_precon_create_ilut_csr(solver,precon);
lis_psolve_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolve_ilut_csr;
lis_psolvet_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolvet_ilut_csr;
break;
#ifdef ENABLE_BSR
case LIS_MATRIX_BSR:
err = lis_precon_create_ilut_bsr(solver,precon);
lis_psolve_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolve_ilut_bsr;
lis_psolvet_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolvet_ilut_bsr;
break;
#endif
default:
A = solver->A;
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;
solver->A = B;
err = lis_precon_create_ilut_csr(solver,precon);
lis_psolve_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolve_ilut_csr;
lis_psolvet_xxx[LIS_PRECON_TYPE_ILUT] = lis_psolvet_ilut_csr;
lis_matrix_destroy(B);
solver->A = A;
break;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
/*! \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;
}
void LisMatrix::setZero()
{
// A matrix has to be destroyed and created again because Lis doesn't provide a
// function to set matrix entries to zero
int ierr = lis_matrix_destroy(_AA);
checkLisError(ierr);
ierr = lis_matrix_create(0, &_AA);
checkLisError(ierr);
ierr = lis_matrix_set_size(_AA, 0, _n_rows);
checkLisError(ierr);
ierr = lis_vector_set_all(0.0, _diag);
checkLisError(ierr);
_is_assembled = false;
}
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_precon_create_sainv(LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT err;
LIS_MATRIX A,B;
LIS_DEBUG_FUNC_IN;
switch( solver->A->matrix_type )
{
case LIS_MATRIX_CSR:
err = lis_precon_create_sainv_csr(solver,precon);
break;
default:
A = solver->A;
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;
solver->A = B;
err = lis_precon_create_sainv_csr(solver,precon);
lis_matrix_destroy(B);
solver->A = A;
break;
}
#ifndef USE_QUAD_PRECISION
err = lis_vector_duplicate(solver->A,&precon->temp);
#else
if( solver->precision==LIS_PRECISION_DEFAULT )
{
err = lis_vector_duplicate(solver->A,&precon->temp);
}
else
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,solver->A,&precon->temp);
}
#endif
if( err ) return err;
precon->A = solver->A;
precon->is_copy = LIS_FALSE;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
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_precon_create_sainv_csr(LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT err;
LIS_INT i,j,k,ii,jj,ik,jk;
LIS_INT n,annz,cl,cu;
LIS_INT *ww,*il,*iu;
LIS_SCALAR t,dd;
LIS_REAL tol,nrm;
LIS_SCALAR *d,*l,*u;
LIS_MATRIX A,B;
LIS_MATRIX_ILU W,Z;
LIS_VECTOR D;
LIS_DEBUG_FUNC_IN;
A = solver->A;
n = A->n;
tol = solver->params[LIS_PARAMS_DROP-LIS_OPTIONS_LEN];
annz = A->n / 10;
W = NULL;
ww = NULL;
d = NULL;
l = NULL;
u = NULL;
il = NULL;
iu = NULL;
err = lis_matrix_ilu_create(n,1,&W);
if( err ) return err;
err = lis_matrix_ilu_create(n,1,&Z);
if( err ) return err;
err = lis_matrix_ilu_setCR(W);
if( err ) return err;
err = lis_matrix_ilu_setCR(Z);
if( err ) return err;
err = lis_vector_duplicate(A,&D);
if( err ) return err;
d = D->value;
err = lis_matrix_ilu_premalloc(annz,W);
if( err ) return err;
err = lis_matrix_ilu_premalloc(annz,Z);
if( err ) return err;
l = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::l");
if( l==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
u = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::u");
if( u==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
il = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::il");
if( il==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
iu = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::iu");
if( iu==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
ww = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::ww");
if( ww==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
err = lis_matrix_convert_csr2csc(A,B);
if( err )
{
return err;
}
for(i=0;i<n;i++) ww[i] = 0;
for(i=0;i<n;i++)
{
W->value[i][0] = 1.0;
W->index[i][0] = i;
W->nnz[i] = 1;
Z->value[i][0] = 1.0;
Z->index[i][0] = i;
Z->nnz[i] = 1;
}
for(i=0; i<n; i++)
{
/* nrm_inf(A[i,:]) */
nrm = 0.0;
for(j=A->ptr[i];j<A->ptr[i+1];j++)
{
nrm = _max(nrm,fabs(A->value[j]));
}
nrm = 1.0/nrm;
/* l = AZ_i */
cl = 0;
memset(l,0,n*sizeof(LIS_SCALAR));
for(k=0;k<Z->nnz[i];k++)
{
ii = Z->index[i][k];
for(j=B->ptr[ii];j<B->ptr[ii+1];j++)
{
jj = B->index[j];
if( jj>i )
{
l[jj] += B->value[j]*Z->value[i][k];
if( ww[jj]==0 )
{
ww[jj] = 1;
il[cl++] = jj;
}
}
}
}
for(k=0;k<cl;k++) ww[il[k]] = 0;
/* u = W_i'A */
cu = 0;
memset(u,0,n*sizeof(LIS_SCALAR));
for(k=0;k<W->nnz[i];k++)
{
ii = W->index[i][k];
for(j=A->ptr[ii];j<A->ptr[ii+1];j++)
{
jj = A->index[j];
#ifdef USE_MPI
if( jj>n-1 ) continue;
#endif
u[jj] += A->value[j]*W->value[i][k];
if( jj>i && ww[jj]==0 )
{
ww[jj] = 1;
iu[cu++] = jj;
}
}
}
for(k=0;k<cu;k++) ww[iu[k]] = 0;
/* d_ii = uZ_i or W_i'l */
t = 0.0;
for(k=0;k<Z->nnz[i];k++)
{
t += u[Z->index[i][k]]*Z->value[i][k];
}
d[i] = 1.0/t;
/* for j>i, l_j!=0 */
/* w_j = w_j - (l_j/d_ii)*w_i */
for(jj=0;jj<cl;jj++)
{
j = il[jj];
dd = l[j]*d[i];
for(k=0;k<W->nnz[j];k++)
{
ww[W->index[j][k]] = k+1;
}
for(ik=0;ik<W->nnz[i];ik++)
{
jk = ww[W->index[i][ik]];
if( jk!=0 )
{
t = dd*W->value[i][ik];
if( fabs(t)*nrm > tol )
{
W->value[j][jk-1] -= t;
}
}
else
{
t = dd*W->value[i][ik];
if( fabs(t)*nrm > tol )
{
if( W->nnz[j] == W->nnz_ma[j] )
{
W->nnz_ma[j] += annz;
err = lis_matrix_ilu_realloc(j,W->nnz_ma[j],W);
if( err ) return err;
}
jk = W->nnz[j];
W->index[j][jk] = W->index[i][ik];
W->value[j][jk] = -t;
W->nnz[j]++;
}
}
}
for(k=0;k<W->nnz[j];k++)
{
ww[W->index[j][k]] = 0;
}
}
/* for j>i, u_j!=0 */
/* z_j = z_j - (u_j/d_ii)*z_i */
for(jj=0;jj<cu;jj++)
{
j = iu[jj];
dd = u[j]*d[i];
for(k=0;k<Z->nnz[j];k++)
{
ww[Z->index[j][k]] = k+1;
}
for(ik=0;ik<Z->nnz[i];ik++)
{
jk = ww[Z->index[i][ik]];
if( jk!=0 )
{
t = dd*Z->value[i][ik];
if( fabs(t)*nrm > tol )
{
Z->value[j][jk-1] -= t;
}
}
else
{
t = dd*Z->value[i][ik];
if( fabs(t)*nrm > tol )
{
if( Z->nnz[j] == Z->nnz_ma[j] )
{
Z->nnz_ma[j] += annz;
err = lis_matrix_ilu_realloc(j,Z->nnz_ma[j],Z);
if( err ) return err;
}
jk = Z->nnz[j];
Z->index[j][jk] = Z->index[i][ik];
Z->value[j][jk] = -t;
Z->nnz[j]++;
}
}
}
for(k=0;k<Z->nnz[j];k++)
{
ww[Z->index[j][k]] = 0;
}
}
}
lis_matrix_destroy(B);
lis_free2(5,l,u,ww,il,iu);
precon->L = W;
precon->U = Z;
precon->D = D;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A;
LIS_VECTOR b,x;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT format;
LIS_INT err;
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 < 4 )
{
err_print:
if( my_rank==0 )
{
printf("%s out_format out_matrix_filename in_matrix_filename [in_rhs_file in_init_file]\n", argv[0]);
}
CHKERR(1);
}
if( strncmp(argv[1], "mmb", 3)==0 )
{
format = LIS_FMT_MMB;
}
else if( strncmp(argv[1], "mm", 2)==0 )
{
format = LIS_FMT_MM;
}
else
{
goto err_print;
}
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[3]);
CHKERR(err);
if( argc>4 )
{
if( !lis_vector_is_null(b) )
{
lis_vector_destroy(b);
err = lis_vector_create(LIS_COMM_WORLD,&b); CHKERR(err);
}
err = lis_input_vector(b,argv[4]);
CHKERR(err);
if( A->n!=b->n )
{
#ifdef _LONGLONG
printf("different dimension: matrix A=%lld, vector b=%lld\n",A->n,b->n);
#else
printf("different dimension: matrix A=%d, vector b=%d\n",A->n,b->n);
#endif
goto err_to;
}
if( argc==6 )
{
if( !lis_vector_is_null(x) )
{
lis_vector_destroy(x);
err = lis_vector_create(LIS_COMM_WORLD,&x); CHKERR(err);
}
err = lis_input_vector(x,argv[5]);
CHKERR(err);
if( A->n!=x->n )
{
#ifdef _LONGLONG
printf("different dimension: matrix A=%lld, vector x=%lld\n",A->n,x->n);
#else
printf("different dimension: matrix A=%d, vector x=%d\n",A->n,x->n);
#endif
goto err_to;
}
}
}
err = lis_output(A,b,x,format,argv[2]);
CHKERR(err);
err_to:
lis_matrix_destroy(A);
lis_vector_destroy(b);
lis_vector_destroy(x);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A,A0;
LIS_VECTOR b,x,v;
LIS_SCALAR ntimes,nmflops,nnrm2;
LIS_SCALAR *value;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nthreads, maxthreads;
LIS_INT gn,nnz,mode;
LIS_INT i,j,jj,j0,j1,l,k,n,np,h,ih;
LIS_INT m,nn,ii;
LIS_INT block;
LIS_INT rn,rmin,rmax,rb;
LIS_INT is,ie,clsize,ci,*iw;
LIS_INT err,iter,matrix_type;
LIS_INT *ptr,*index;
double mem,val,ra,rs,ri,ria,ca,time,time2,convtime,val2,nnzs,nnzap,nnzt;
double commtime,comptime,flops;
FILE *file;
char path[1024];
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 < 4 )
{
if( my_rank==0 ) printf("Usage: spmvtest5 matrix_filename matrix_type iter [block] \n");
lis_finalize();
exit(0);
}
file = fopen(argv[1], "r");
if( file==NULL ) CHKERR(1);
matrix_type = atoi(argv[2]);
iter = atoi(argv[3]);
if (argv[4] == NULL) {
block = 2;
}
else {
block = atoi(argv[4]);
}
if( matrix_type<1 || matrix_type>11 )
{
if( my_rank==0 ) printf("matrix_type=%d <1 or matrix_type=%d >11\n",matrix_type,matrix_type);
CHKERR(1);
}
if( iter<=0 )
{
if( my_rank==0 ) printf("iter=%d <= 0\n",iter);
CHKERR(1);
}
if( my_rank==0 )
{
printf("\n");
printf("number of processes = %d\n",nprocs);
}
#ifdef _OPENMP
if( my_rank==0 )
{
nthreads = omp_get_num_procs();
maxthreads = omp_get_max_threads();
printf("max number of threads = %d\n", nthreads);
printf("number of threads = %d\n", maxthreads);
}
#else
nthreads = 1;
maxthreads = 1;
#endif
/* create matrix and vectors */
lis_matrix_create(LIS_COMM_WORLD,&A0);
err = lis_input(A0,NULL,NULL,argv[1]);
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 )
{
printf("block size of BSR and BSC = %d x %d\n",block,block);
printf("iteration count = %d\n\n",iter);
}
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);
}
lis_matrix_duplicate(A0,&A);
lis_matrix_set_type(A,matrix_type);
err = lis_matrix_convert(A0,A);
if( err ) CHKERR(err);
if( A->matrix_type==LIS_MATRIX_BSR || A->matrix_type==LIS_MATRIX_BSC )
{
A->bnr = block;
A->bnc = block;
}
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;
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);
}
lis_matrix_destroy(A);
lis_matrix_destroy(A0);
lis_vector_destroy(b);
lis_vector_destroy(x);
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_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 lis_matrix_create_rco(LIS_INT local_n, LIS_INT global_n, LIS_Comm comm, LIS_INT annz, LIS_INT *nnz, LIS_MATRIX *Amat)
{
LIS_INT nprocs,my_rank;
LIS_INT is,ie,err;
LIS_INT i,k;
LIS_INT *ranges;
LIS_DEBUG_FUNC_IN;
*Amat = NULL;
if( global_n>0 && local_n>global_n )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) is larger than global n(=%d)\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n<0 || global_n<0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) or global n(=%d) are less than 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
if( local_n==0 && global_n==0 )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"local n(=%d) and global n(=%d) are 0\n",local_n,global_n);
return LIS_ERR_ILL_ARG;
}
*Amat = (LIS_MATRIX)lis_malloc( sizeof(struct LIS_MATRIX_STRUCT),"lis_matrix_create_rco::Amat" );
if( NULL==*Amat )
{
LIS_SETERR_MEM(sizeof(struct LIS_MATRIX_STRUCT));
return LIS_OUT_OF_MEMORY;
}
lis_matrix_init(Amat);
err = lis_ranges_create(comm,&local_n,&global_n,&ranges,&is,&ie,&nprocs,&my_rank);
if( err )
{
lis_matrix_destroy(*Amat);
*Amat = NULL;
return err;
}
(*Amat)->ranges = ranges;
(*Amat)->w_nnz = (LIS_INT *)lis_malloc(local_n*sizeof(LIS_INT),"lis_matrix_create_rco::Amat->w_nnz");
if( (*Amat)->w_nnz==NULL )
{
LIS_SETERR_MEM(local_n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
if( nnz==NULL )
{
(*Amat)->w_annz = annz;
for(k=0;k<local_n;k++) (*Amat)->w_nnz[k] = (*Amat)->w_annz;
}
else
{
i = 0;
for(k=0;k<local_n;k++)
{
(*Amat)->w_nnz[k] = nnz[k];
i += nnz[k];
}
(*Amat)->w_annz = i/local_n;
}
err = lis_matrix_malloc_rco(local_n,(*Amat)->w_nnz,&(*Amat)->w_row,&(*Amat)->w_index,&(*Amat)->w_value);
if( err )
{
lis_free((*Amat)->w_nnz);
return err;
}
(*Amat)->status = LIS_MATRIX_ASSEMBLING;
(*Amat)->n = local_n;
(*Amat)->gn = global_n;
(*Amat)->np = local_n;
(*Amat)->comm = comm;
(*Amat)->my_rank = my_rank;
(*Amat)->nprocs = nprocs;
(*Amat)->is = is;
(*Amat)->ie = ie;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
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 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;
}
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_MATRIX A,A0;
LIS_VECTOR b,x,v;
LIS_SCALAR ntimes,nmflops,nnrm2;
LIS_SCALAR *value;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nthreads, maxthreads;
LIS_INT gn,nnz,mode;
LIS_INT i,ii,j,jj,j0,j1,l,k,n,np,h,ih;
LIS_INT rn,rmin,rmax,rb;
LIS_INT is,ie,clsize,ci,*iw;
LIS_INT err,iter,matrix_type,s,ss,se;
LIS_INT *ptr,*index;
double mem,ra,rs,ri,ria,ca,time,time2,convtime,nnzs,nnzap,nnzt;
LIS_SCALAR val;
double commtime,comptime,flops;
FILE *file;
char path[1024];
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 iter [matrix_type]\n", argv[0]);
}
CHKERR(1);
}
n = atoi(argv[1]);
iter = atoi(argv[2]);
if (argv[3] == NULL) {
s = 0;
}
else {
s = atoi(argv[3]);
}
if( n<=0 )
{
#ifdef _LONGLONG
if( my_rank==0 ) printf("n=%lld <=0\n",n);
#else
if( my_rank==0 ) printf("n=%d <=0\n",n);
#endif
CHKERR(1);
}
if( iter<=0 )
{
#ifdef _LONGLONG
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( s<0 || s>11 )
{
#ifdef _LONGLONG
if( my_rank==0 ) printf("matrix_type=%lld < 0 or matrix_type=%lld > 11\n",s,s);
#else
if( my_rank==0 ) printf("matrix_type=%d < 0 or matrix_type=%d > 11\n",s,s);
#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
nthreads = omp_get_num_procs();
maxthreads = omp_get_max_threads();
if( my_rank==0 )
{
#ifdef _LONGLONG
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 */
lis_matrix_create(LIS_COMM_WORLD,&A0);
lis_matrix_set_size(A0,0,n);
lis_matrix_get_size(A0,&n,&gn);
lis_matrix_get_range(A0,&is,&ie);
k = 0;
for(i=is;i<ie;i++)
{
if( i>0 ) lis_matrix_set_value(LIS_INS_VALUE,i,i-1,-1.0,A0);
if( i<gn-1 ) lis_matrix_set_value(LIS_INS_VALUE,i,i+1,-1.0,A0);
lis_matrix_set_value(LIS_INS_VALUE,i,i,2.0,A0);
}
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 _LONGLONG
printf("matrix size = %lld x %lld (%lld nonzero entries)\n",gn,gn,nnz);
printf("iteration count = %lld\n\n",iter);
#else
printf("matrix size = %d x %d (%d nonzero entries)\n",gn,gn,nnz);
printf("iteration count = %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);
}
/*
MPI version of VBR is not implemented.
DNS is also excluded to reduce memory usage.
*/
if (s==0)
{
ss = 1;
se = 11;
}
else
{
ss = s;
se = s+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;
MPI_Barrier(A->comm);
#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 _LONGLONG
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 _LONGLONG
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 _LONGLONG
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 _LONGLONG
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;
}
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;
}
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_precon_create_sainv_csr(LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT err;
LIS_INT i,j,k,ii,jj,len,lfil;
LIS_INT n,nnz,annz,cl,cu,cc,m;
LIS_INT *wu,*wl,*il,*iu,*ic,*pc;
LIS_SCALAR t,v;
LIS_REAL tol,tol_dd,nrm;
LIS_SCALAR *d,*r,*c,*l,*u,*tmp;
LIS_MATRIX A,B;
LIS_MATRIX_ILU W,Z;
LIS_VECTOR D;
LIS_DEBUG_FUNC_IN;
A = solver->A;
n = A->n;
nnz = A->nnz;
tol = solver->params[LIS_PARAMS_DROP-LIS_OPTIONS_LEN];
m = solver->params[LIS_PARAMS_RATE-LIS_OPTIONS_LEN];
annz = 10+A->nnz / A->n;
lfil = (LIS_INT)((double)A->nnz/(2.0*n))*m;
W = NULL;
Z = NULL;
wu = NULL;
wl = NULL;
d = NULL;
l = NULL;
u = NULL;
il = NULL;
iu = NULL;
err = lis_matrix_ilu_create(n,1,&W);
if( err ) return err;
err = lis_matrix_ilu_create(n,1,&Z);
if( err ) return err;
err = lis_matrix_ilu_setCR(W);
if( err ) return err;
err = lis_matrix_ilu_setCR(Z);
if( err ) return err;
err = lis_vector_duplicate(A,&D);
if( err ) return err;
d = D->value;
tmp = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::l");
if( tmp==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
r = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::l");
if( r==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
c = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::u");
if( c==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
l = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::l");
if( l==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
u = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_precon_create_sainv_csr::u");
if( u==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_SCALAR));
return LIS_OUT_OF_MEMORY;
}
il = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::il");
if( il==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
iu = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::iu");
if( iu==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
ic = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::iu");
if( ic==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
wu = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::ww");
if( wu==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
wl = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::ww");
if( wl==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
pc = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_precon_create_sainv_csr::iu");
if( pc==NULL )
{
LIS_SETERR_MEM(n*sizeof(LIS_INT));
return LIS_OUT_OF_MEMORY;
}
lis_matrix_sort_csr(A);
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
err = lis_matrix_convert_csr2csc(A,B);
if( err ) return err;
for(i=0;i<n;i++)
{
wu[i] = 0;
wl[i] = 0;
pc[i] = A->ptr[i];
}
for(i=0; i<n; i++)
{
/* nrm_inf(A[i,:]) */
nrm = 0.0;
for(j=A->ptr[i];j<A->ptr[i+1];j++)
{
nrm = _max(nrm,fabs(A->value[j]));
}
tol_dd = nrm * tol;
/* l = e_i */
/* u = e_i */
l[i] = 1.0;
u[i] = 1.0;
il[0] = i;
iu[0] = i;
cl = 1;
cu = 1;
wu[i] = 1;
wl[i] = 1;
cc = 0;
/* r = e_i^T*A */
for(j=A->ptr[i];j<A->ptr[i+1];j++)
{
jj = A->index[j];
r[jj] = A->value[j];
}
/* c = A_i = A*e_i */
for(j=B->ptr[i];j<B->ptr[i+1];j++)
{
jj = B->index[j];
c[jj] = B->value[j];
}
/* W_i = W_i - (r*Z_j/D_jj)*W_j */
for(j=0;j<i;j++)
{
t = 0.0;
for(k=0;k<Z->nnz[j];k++)
{
t += r[Z->index[j][k]]*Z->value[j][k];
}
t = t * d[j];
if( fabs(t) > tol_dd )
{
for(k=0;k<W->nnz[j];k++)
{
v = t * W->value[j][k];
if( fabs(v) > tol_dd )
{
jj = W->index[j][k];
if( wl[jj]==1 )
{
l[jj] -= v;
}
else
{
l[jj] = -v;
il[cl++] = jj;
wl[jj] = 1;
}
}
}
}
}
/* Z_i = Z_i - (W_j^T*c/D_jj)*Z_j */
for(j=0;j<i;j++)
{
t = 0.0;
for(k=0;k<W->nnz[j];k++)
{
t += c[W->index[j][k]]*W->value[j][k];
}
t = t * d[j];
if( fabs(t) > tol_dd )
{
for(k=0;k<Z->nnz[j];k++)
{
v = t * Z->value[j][k];
if( fabs(v) > tol_dd )
{
jj = Z->index[j][k];
if( wu[jj]==1 )
{
u[jj] -= v;
}
else
{
u[jj] = -v;
iu[cu++] = jj;
wu[jj] = 1;
}
}
}
}
}
/*
len = _min(lfil,cl);
for(j=0;j<cl;j++) tmp[j] = fabs(l[il[j]]);
lis_sort_di(0,cl-1,tmp,il);
lis_sort_i(0,len-1,il);
cl = len;
*/
/*
k = cl;
for(j=0;j<cl;j++)
{
if( fabs(l[il[j]])<= tol_dd )
{
wl[il[j]] = 0;
il[j] = n;
k--;
}
}
lis_sort_i(0,cl-1,il);
cl = k;
k = cu;
for(j=0;j<cu;j++)
{
if( fabs(u[iu[j]])<= tol_dd )
{
wu[iu[j]] = 0;
iu[j] = n;
k--;
}
}
lis_sort_i(0,cu-1,iu);
cu = k;
*/
W->nnz[i] = cl;
if( cl > 0 )
{
W->index[i] = (LIS_INT *)malloc(cl*sizeof(LIS_INT));
W->value[i] = (LIS_SCALAR *)malloc(cl*sizeof(LIS_SCALAR));
memcpy(W->index[i],il,cl*sizeof(LIS_INT));
for(j=0;j<cl;j++)
{
W->value[i][j] = l[il[j]];
}
}
Z->nnz[i] = cu;
if( cu > 0 )
{
Z->index[i] = (LIS_INT *)malloc(cu*sizeof(LIS_INT));
Z->value[i] = (LIS_SCALAR *)malloc(cu*sizeof(LIS_SCALAR));
memcpy(Z->index[i],iu,cu*sizeof(LIS_INT));
for(j=0;j<cu;j++)
{
Z->value[i][j] = u[iu[j]];
}
}
for(j=A->ptr[i];j<A->ptr[i+1];j++) r[A->index[j]] = 0.0;
for(j=B->ptr[i];j<B->ptr[i+1];j++) c[B->index[j]] = 0.0;
for(j=0;j<cl;j++)
{
wl[il[j]] = 0;
l[il[j]] = 0.0;
}
for(j=0;j<cu;j++)
{
wu[iu[j]] = 0;
}
/* D_ii = W_i^T * A * Z_i */
cl = 0;
for(k=0;k<Z->nnz[i];k++)
{
ii = Z->index[i][k];
for(j=B->ptr[ii];j<B->ptr[ii+1];j++)
{
jj = B->index[j];
if( wl[jj]==0 )
{
l[jj] = B->value[j]*Z->value[i][k];
wl[jj] = 1;
il[cl++] = jj;
}
else
{
l[jj] += B->value[j]*Z->value[i][k];
}
}
}
t = 0.0;
for(j=0;j<W->nnz[i];j++)
{
k = W->index[i][j];
t += W->value[i][j] * l[k];
}
d[i] = 1.0 / t;
for(j=0;j<cl;j++) wl[il[j]] = 0;
}
lis_matrix_destroy(B);
lis_free2(11,r,c,il,l,wl,iu,u,wu,ic,pc,tmp);
precon->L = W;
precon->U = Z;
precon->D = D;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_matrix_copyDLU_csr(LIS_MATRIX Ain, LIS_MATRIX_DIAG *D, LIS_MATRIX *L, LIS_MATRIX *U)
{
LIS_INT err;
LIS_INT i,n,np,lnnz,unnz;
LIS_INT *lptr,*lindex;
LIS_INT *uptr,*uindex;
LIS_SCALAR *lvalue,*uvalue,*diag;
LIS_DEBUG_FUNC_IN;
*D = NULL;
*L = NULL;
*U = NULL;
err = lis_matrix_check(Ain,LIS_MATRIX_CHECK_ALL);
if( err ) return err;
n = Ain->n;
np = Ain->np;
err = lis_matrix_duplicate(Ain,L);
if( err )
{
return err;
}
err = lis_matrix_duplicate(Ain,U);
if( err )
{
lis_matrix_destroy(*L);
return err;
}
err = lis_matrix_diag_duplicateM(Ain,D);
if( err )
{
lis_matrix_destroy(*L);
lis_matrix_destroy(*U);
return err;
}
lis_free((*D)->value);
if( Ain->is_splited )
{
}
lnnz = Ain->L->nnz;
unnz = Ain->U->nnz;
lptr = NULL;
lindex = NULL;
uptr = NULL;
uindex = NULL;
diag = NULL;
err = lis_matrix_malloc_csr(n,lnnz,&lptr,&lindex,&lvalue);
if( err )
{
return err;
}
err = lis_matrix_malloc_csr(n,unnz,&uptr,&uindex,&uvalue);
if( err )
{
lis_free2(7,diag,uptr,lptr,uindex,lindex,uvalue,lvalue);
return err;
}
diag = (LIS_SCALAR *)lis_malloc(np*sizeof(LIS_SCALAR),"lis_matrix_copyDLU_csr::diag");
if( diag==NULL )
{
lis_free2(7,diag,uptr,lptr,uindex,lindex,uvalue,lvalue);
return err;
}
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<n;i++)
{
diag[i] = Ain->D->value[i];
}
lis_matrix_elements_copy_csr(n,Ain->L->ptr,Ain->L->index,Ain->L->value,lptr,lindex,lvalue);
lis_matrix_elements_copy_csr(n,Ain->U->ptr,Ain->U->index,Ain->U->value,uptr,uindex,uvalue);
(*D)->value = diag;
err = lis_matrix_set_csr(lnnz,lptr,lindex,lvalue,*L);
if( err )
{
lis_free2(7,diag,uptr,lptr,uindex,lindex,uvalue,lvalue);
return err;
}
err = lis_matrix_set_csr(unnz,uptr,uindex,uvalue,*U);
if( err )
{
lis_free2(7,diag,uptr,lptr,uindex,lindex,uvalue,lvalue);
return err;
}
err = lis_matrix_assemble(*L);
if( err )
{
return err;
}
err = lis_matrix_assemble(*U);
if( err )
{
return err;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_precon_create_saamg(LIS_SOLVER solver, LIS_PRECON precon)
{
#if defined(USE_SAAMG)
LIS_MATRIX A,B;
LIS_COMMTABLE table;
LIS_INT i;
LIS_INT unsym,sol;
LIS_INT err;
LIS_REAL theta;
#ifdef USE_MPI
LIS_MPI_Fint comm;
#endif
LIS_DEBUG_FUNC_IN;
if( solver->A->matrix_type!=LIS_MATRIX_CRS )
{
A = solver->A;
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
lis_matrix_set_type(B,LIS_MATRIX_CRS);
err = lis_matrix_convert(A,B);
if( err ) return err;
solver->A = B;
lis_matrix_destroy(B);
solver->A = A;
}
precon->A = solver->A;
precon->is_copy = LIS_FALSE;
A = precon->A;
sol = solver->options[LIS_OPTIONS_SOLVER];
unsym = solver->options[LIS_OPTIONS_SAAMG_UNSYM];
theta = solver->params[LIS_PARAMS_SAAMG_THETA - LIS_OPTIONS_LEN];
#if 0
if( sol!=LIS_SOLVER_CG && !unsym )
{
unsym = LIS_TRUE;
}
#endif
err = lis_vector_duplicate(A,&precon->temp);
if( err )
{
return err;
}
F77_FUNC_(finit_data_creation,FINIT_DATA_CREATION)(c_data_creation_ptr_bar);
F77_FUNC_(finit_data_creation_unsym,FINIT_DATA_CREATION_UNSYM)(c_data_creation_unsym_ptr_bar);
F77_FUNC_(finit_v_cycle,FINIT_V_CYCLE)(c_v_cycle_ptr_bar);
F77_FUNC_(finit_clear_matrix,FINIT_CLEAR_MATRIX)(c_clear_matrix_ptr_bar);
lis_matrix_split(A);
#ifdef USE_MPI
comm = MPI_Comm_c2f(A->comm);
lis_send_recv(A->commtable,A->D->value);
table = A->commtable;
if( !unsym )
{
(*(void (*)())f_data_creation_ptr)(&A->n,&A->np,&A->L->nnz,&A->U->nnz,
A->D->value,A->L->value,A->L->ptr,A->L->index,
A->U->value, A->U->ptr, A->U->index,
&table->neibpetot, table->neibpe, table->import_ptr,
table->import_index, table->export_ptr, table->export_index,
&table->imnnz,&table->exnnz,
&comm, &precon->level_num,&precon->wsize, &theta);
}
else
{
(*(void (*)())f_data_creation_unsym_ptr)(&A->n,&A->np,&A->L->nnz,&A->U->nnz,
A->D->value,A->L->value,A->L->ptr,A->L->index,
A->U->value, A->U->ptr, A->U->index,
&table->neibpetot, table->neibpe, table->import_ptr,
table->import_index, table->export_ptr, table->export_index,
&table->imnnz,&table->exnnz,
&comm, &precon->level_num,&precon->wsize, &theta);
}
#else
if( !unsym )
{
(*(void (*)())f_data_creation_ptr)(&A->n,&A->L->nnz,&A->U->nnz,
A->D->value,A->L->value,A->L->ptr,A->L->index,
A->U->value, A->U->ptr, A->U->index, &precon->level_num, &theta);
}
else
{
(*(void (*)())f_data_creation_unsym_ptr)(&A->n,&A->L->nnz,&A->U->nnz,
A->D->value,A->L->value,A->L->ptr,A->L->index,
A->U->value, A->U->ptr, A->U->index, &precon->level_num, &theta);
}
#endif
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
#else
LIS_DEBUG_FUNC_IN;
precon->A = solver->A;
precon->is_copy = LIS_FALSE;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
#endif
}
LIS_INT main(LIS_INT argc, char* argv[])
{
LIS_MATRIX A,A0;
LIS_VECTOR b,x;
LIS_INT nprocs,my_rank;
int int_nprocs,int_my_rank;
LIS_INT nthreads, maxthreads;
LIS_INT nnz;
LIS_INT i,n,np;
LIS_INT block;
LIS_INT is,ie;
LIS_INT err,iter,matrix_type;
double time,time2,nnzs,nnzap,nnzt;
LIS_SCALAR val;
double commtime,comptime,flops;
char path[1024];
FILE *file;
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 matrix_filename_list iter [block] \n", argv[0]);
}
lis_finalize();
exit(0);
}
file = fopen(argv[1], "r");
if( file==NULL ) CHKERR(1);
iter = atoi(argv[2]);
if (argv[3] == NULL) {
block = 2;
}
else {
block = atoi(argv[3]);
}
if( iter<=0 )
{
#ifdef _LONG__LONG
printf("iter=%lld <= 0\n",iter);
#else
printf("iter=%d <= 0\n",iter);
#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
if( my_rank==0 )
{
nthreads = omp_get_num_procs();
maxthreads = omp_get_max_threads();
#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 */
while( fscanf(file, "%s\n", path)==1 )
{
if( my_rank==0 )
{
printf("matrix_filename = %s\n", path);
}
lis_matrix_create(LIS_COMM_WORLD,&A0);
err = lis_input(A0,NULL,NULL,path);
if( err ) CHKERR(err);
n = A0->n;
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("block size of BSR and BSC = %lld x %lld\n",block,block);
printf("number of iterations = %lld\n\n",iter);
#else
printf("block size of BSR and BSC = %d x %d\n",block,block);
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);
}
/*
MPI version of VBR is not implemented.
DNS is also excluded to reduce memory usage.
*/
for (matrix_type=1;matrix_type<11;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);
if( my_rank==0 )
{
if( A->matrix_type==LIS_MATRIX_BSR || A->matrix_type==LIS_MATRIX_BSC )
{
A->bnr = block;
A->bnc = block;
}
}
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);
}
fclose(file);
lis_finalize();
LIS_DEBUG_FUNC_OUT;
return 0;
}
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(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;
}
