LisMatrix::LisMatrix(std::size_t n_rows, int nnz, IndexType *row_ptr,
IndexType *col_idx, double *data)
: _n_rows(n_rows),
_mat_type(MatrixType::CRS),
_is_assembled(false),
_use_external_arrays(true)
{
int ierr = lis_matrix_create(0, &_AA);
checkLisError(ierr);
ierr = lis_matrix_set_size(_AA, 0, n_rows);
checkLisError(ierr);
ierr = lis_matrix_set_csr(nnz, row_ptr, col_idx, data, _AA);
checkLisError(ierr);
ierr = lis_matrix_assemble(_AA);
checkLisError(ierr);
_is_assembled = true;
lis_matrix_get_range(_AA, &_is, &_ie);
ierr = lis_vector_duplicate(_AA, &_diag);
checkLisError(ierr);
}
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_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_matrix_copy_csr(LIS_MATRIX Ain, LIS_MATRIX Aout)
{
LIS_INT err;
LIS_INT i,n,nnz,lnnz,unnz;
LIS_INT *ptr,*index;
LIS_INT *lptr,*lindex;
LIS_INT *uptr,*uindex;
LIS_SCALAR *value,*lvalue,*uvalue,*diag;
LIS_DEBUG_FUNC_IN;
n = Ain->n;
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(n*sizeof(LIS_SCALAR),"lis_matrix_copy_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);
err = lis_matrix_setDLU_csr(lnnz,unnz,diag,lptr,lindex,lvalue,uptr,uindex,uvalue,Aout);
if( err )
{
lis_free2(7,diag,uptr,lptr,uindex,lindex,uvalue,lvalue);
return err;
}
}
if( !Ain->is_splited || (Ain->is_splited && Ain->is_save) )
{
ptr = NULL;
index = NULL;
value = NULL;
nnz = Ain->nnz;
err = lis_matrix_malloc_csr(n,nnz,&ptr,&index,&value);
if( err )
{
return err;
}
lis_matrix_elements_copy_csr(n,Ain->ptr,Ain->index,Ain->value,ptr,index,value);
err = lis_matrix_set_csr(nnz,ptr,index,value,Aout);
if( err )
{
lis_free2(3,ptr,index,value);
return err;
}
}
if( Ain->matrix_type==LIS_MATRIX_CSC )
{
Aout->matrix_type = LIS_MATRIX_CSC;
Aout->status = -LIS_MATRIX_CSC;
err = lis_matrix_assemble(Aout);
}
else
{
err = lis_matrix_assemble(Aout);
}
if( err )
{
lis_matrix_storage_destroy(Aout);
return err;
}
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_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 lis_input_mm_csr(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, FILE *file)
{
char buf[BUFSIZE];
LIS_INT nr,nc,nnz;
LIS_INT i,j,my_rank;
LIS_INT err;
LIS_INT mmtype,mode;
LIS_INT n,is,ie;
LIS_INT ridx,cidx;
LIS_INT *ptr, *index;
LIS_INT *work;
LIS_INT isb,isx,isbin;
LIS_SCALAR val;
LIS_SCALAR *value;
LIS_MM_MATFMT matfmt;
LIS_DEBUG_FUNC_IN;
#ifdef USE_MPI
my_rank = A->my_rank;
#else
my_rank = 0;
#endif
/* check banner */
err = lis_input_mm_banner(file,&mmtype);
if( err ) return err;
/* check size */
err = lis_input_mm_size(file,&nr,&nc,&nnz,&isb,&isx,&isbin);
if( err ) return err;
err = lis_matrix_set_size(A,0,nr);
if( err ) return err;
#ifdef _LONGLONG
if( my_rank==0 ) printf("matrix size = %lld x %lld (%lld nonzero entries)\n\n",nr,nc,nnz);
#else
if( my_rank==0 ) printf("matrix size = %d x %d (%d nonzero entries)\n\n",nr,nc,nnz);
#endif
n = A->n;
ptr = NULL;
index = NULL;
value = NULL;
work = NULL;
lis_matrix_get_range(A,&is,&ie);
ptr = (LIS_INT *)lis_malloc( (n+1)*sizeof(LIS_INT),"lis_input_mm_csr::ptr" );
if( ptr==NULL )
{
LIS_SETERR_MEM((n+1)*sizeof(LIS_INT));
lis_free2(4,ptr,index,value,work);
return LIS_OUT_OF_MEMORY;
}
work = (LIS_INT *)lis_malloc( (n+1)*sizeof(LIS_INT),"lis_input_mm_csr::work" );
if( work==NULL )
{
LIS_SETERR_MEM((n+1)*sizeof(LIS_INT));
lis_free2(4,ptr,index,value,work);
return LIS_OUT_OF_MEMORY;
}
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<n+1;i++)
{
ptr[i] = 0;
work[i] = 0;
}
/* read data */
mode = 1;
mode = *(char *)&mode;
if( mode!=(isbin-1) )
{
mode = LIS_TRUE;
}
else
{
mode = LIS_FALSE;
}
for( i=0; i<nnz; i++ )
{
if( isbin )
{
if( fread(&matfmt, sizeof(matfmt), 1, file)!=1 )
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
ridx = matfmt.i;
cidx = matfmt.j;
if( mode )
{
lis_bswap_int(1,&ridx);
lis_bswap_int(1,&cidx);
}
}
else
{
if( fgets(buf, BUFSIZE, file)==NULL )
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%lld %lld %Lg", &ridx, &cidx, &val) != 3 )
#else
if( sscanf(buf, "%lld %lld %lg", &ridx, &cidx, &val) != 3 )
#endif
#else
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%d %d %Lg", &ridx, &cidx, &val) != 3 )
#else
if( sscanf(buf, "%d %d %lg", &ridx, &cidx, &val) != 3 )
#endif
#endif
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
}
/* if( val!=0.0 )*/
{
if( mmtype==MM_SYMM && ridx!=cidx )
{
if( cidx>is && cidx<=ie ) work[cidx-is-1]++;
}
if( ridx>is && ridx<=ie )
{
ptr[ridx-is]++;
}
}
}
ptr[0] = 0;
for( i=0; i<n; i++ )
{
if( mmtype==MM_SYMM )
{
ptr[i+1] += ptr[i] + work[i];
}
else
{
ptr[i+1] += ptr[i];
}
work[i] = 0;
}
index = (LIS_INT *)lis_malloc( ptr[n]*sizeof(LIS_INT),"lis_input_mm_csr::index" );
if( index==NULL )
{
LIS_SETERR_MEM(ptr[n]*sizeof(LIS_INT));
lis_free2(4,ptr,index,value,work);
return LIS_OUT_OF_MEMORY;
}
value = (LIS_SCALAR *)lis_malloc( ptr[n]*sizeof(LIS_SCALAR),"lis_input_mm_csr::value" );
if( value==NULL )
{
LIS_SETERR_MEM(ptr[n]*sizeof(LIS_SCALAR));
lis_free2(4,ptr,index,value,work);
return LIS_OUT_OF_MEMORY;
}
#ifdef _OPENMP
#pragma omp parallel for private(i,j)
#endif
for(i=0;i<n;i++)
{
for(j=ptr[i];j<ptr[i+1];j++)
{
index[j] = 0;
value[j] = 0.0;
}
}
rewind(file);
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
do
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
}while( buf[0]=='%' );
for( i=0; i<nnz; i++ )
{
if( isbin )
{
if( fread(&matfmt, sizeof(matfmt), 1, file)!=1 )
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
ridx = matfmt.i;
cidx = matfmt.j;
val = matfmt.value;
if( mode )
{
lis_bswap_int(1,&ridx);
lis_bswap_int(1,&cidx);
lis_bswap_scalar(1,&val);
}
}
else
{
if( fgets(buf, BUFSIZE, file) == NULL )
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
#ifdef _LONGLONG
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%lld %lld %Lg", &ridx, &cidx, &val) != 3 )
#else
if( sscanf(buf, "%lld %lld %lg", &ridx, &cidx, &val) != 3 )
#endif
#else
#ifdef _LONG__DOUBLE
if( sscanf(buf, "%d %d %Lg", &ridx, &cidx, &val) != 3 )
#else
if( sscanf(buf, "%d %d %lg", &ridx, &cidx, &val) != 3 )
#endif
#endif
{
LIS_SETERR_FIO;
lis_free2(4,ptr,index,value,work);
return LIS_ERR_FILE_IO;
}
}
ridx--;
cidx--;
if( ridx==cidx && val==0.0 )
{
#ifdef _LONGLONG
printf("diagonal element is zero (i=%lld)\n",ridx);
#else
printf("diagonal element is zero (i=%d)\n",ridx);
#endif
}
/* if( val!=0.0 )*/
{
if( mmtype==MM_SYMM && ridx!=cidx )
{
if( cidx>=is && cidx<ie )
{
value[ptr[cidx-is]+work[cidx-is]] = val;
index[ptr[cidx-is]+work[cidx-is]] = ridx;
work[cidx-is]++;
}
}
if( ridx>=is && ridx<ie )
{
value[ptr[ridx-is]+work[ridx-is]] = val;
index[ptr[ridx-is]+work[ridx-is]] = cidx;
work[ridx-is]++;
}
}
}
#ifdef USE_MPI
MPI_Barrier(A->comm);
#endif
err = lis_matrix_set_csr(ptr[n],ptr,index,value,A);
if( err )
{
lis_free2(4,ptr,index,value,work);
return err;
}
err = lis_matrix_assemble(A);
if( err )
{
lis_matrix_storage_destroy(A);
lis_free(work);
return err;
}
if( b!=NULL && x!=NULL )
{
err = lis_input_mm_vec(A,b,x,file,isb,isx,isbin);
if( err )
{
lis_matrix_storage_destroy(A);
lis_free(work);
}
}
lis_free(work);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_matrix_convert_msr2csr(LIS_MATRIX Ain, LIS_MATRIX Aout)
{
LIS_INT i,j,k;
LIS_INT err;
LIS_INT n,nnz,is;
LIS_INT *ptr,*index;
LIS_SCALAR *value;
LIS_DEBUG_FUNC_IN;
n = Ain->n;
nnz = Ain->nnz;
is = Ain->is;
ptr = NULL;
index = NULL;
value = NULL;
err = lis_matrix_malloc_csr(n,nnz,&ptr,&index,&value);
if( err )
{
return err;
}
/* convert csr */
#ifdef _OPENMP
#pragma omp parallel for private(i)
#endif
for(i=0;i<n;i++)
{
ptr[i+1] = Ain->index[i+1] - Ain->index[i];
if( Ain->value[i]!=0.0 )
{
ptr[i+1]++;
}
}
ptr[0] = 0;
for(i=0;i<n;i++)
{
ptr[i+1] += ptr[i];
}
#ifdef _OPENMP
#pragma omp parallel for private(i,j,k)
#endif
for(i=0;i<n;i++)
{
k = ptr[i];
if( Ain->value[i]!=(LIS_SCALAR)0.0 )
{
value[k] = Ain->value[i];
index[k] = i;
k++;
}
for(j=Ain->index[i];j<Ain->index[i+1];j++)
{
value[k] = Ain->value[j];
index[k] = Ain->index[j];
k++;
}
}
err = lis_matrix_set_csr(nnz,ptr,index,value,Aout);
if( err )
{
lis_free2(3,ptr,index,value);
return err;
}
err = lis_matrix_assemble(Aout);
if( err )
{
lis_matrix_storage_destroy(Aout);
return err;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_matrix_convert_rco2csr(LIS_MATRIX Ain, LIS_MATRIX Aout)
{
LIS_INT i,j,k,n,nnz,err;
LIS_INT *ptr,*index;
LIS_SCALAR *value;
LIS_DEBUG_FUNC_IN;
ptr = NULL;
index = NULL;
value = NULL;
n = Ain->n;
nnz = 0;
#ifdef _OPENMP
#pragma omp parallel for reduction(+:nnz) private(i)
#endif
for(i=0;i<n;i++)
{
nnz += Ain->w_row[i];
}
err = lis_matrix_malloc_csr(n,nnz,&ptr,&index,&value);
if( err )
{
return err;
}
#ifdef _NUMA
#pragma omp parallel for private(i)
for(i=0;i<n+1;i++) ptr[i] = 0;
#else
ptr[0] = 0;
#endif
for(i=0;i<n;i++)
{
ptr[i+1] = ptr[i] + Ain->w_row[i];
}
#ifdef _OPENMP
#pragma omp parallel for private(i,j,k)
#endif
for(i=0;i<n;i++)
{
k = ptr[i];
for(j=0;j<Ain->w_row[i];j++)
{
index[k] = Ain->w_index[i][j];
value[k] = Ain->w_value[i][j];
k++;
}
}
err = lis_matrix_set_csr(nnz,ptr,index,value,Aout);
if( err )
{
lis_free2(3,ptr,index,value);
return err;
}
err = lis_matrix_assemble(Aout);
if( err )
{
lis_matrix_storage_destroy(Aout);
return err;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
