void lis_matrix_assemble_f(LIS_MATRIX_F *A, LIS_INT *ierr) { LIS_MATRIX AA; LIS_DEBUG_FUNC_IN; AA = (LIS_MATRIX)LIS_V2P(A); *ierr = lis_matrix_assemble(AA); *A = LIS_P2V(AA); LIS_DEBUG_FUNC_OUT; return; }
bool finalizeMatrixAssembly(LisMatrix &mat) { LIS_MATRIX &A = mat.getRawMatrix(); if (!mat.isAssembled()) { int ierr = lis_matrix_set_type(A, static_cast<int>(mat.getMatrixType())); checkLisError(ierr); ierr = lis_matrix_assemble(A); checkLisError(ierr); mat._is_assembled = true; } return true; }
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 lis_esolver_get_evectors(LIS_ESOLVER esolver, LIS_MATRIX M) { LIS_INT i,ii,j,jj,n,gn,is,ie,js; LIS_INT ss,lis_esolver_evector_size; LIS_DEBUG_FUNC_IN; if ( esolver->options[LIS_EOPTIONS_ESOLVER] != LIS_ESOLVER_SI && esolver->options[LIS_EOPTIONS_ESOLVER] != LIS_ESOLVER_LI && esolver->options[LIS_EOPTIONS_ESOLVER] != LIS_ESOLVER_AI ) { LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_EOPTIONS_ESOLVER is %d (Set Subspace, Lanczos, or Arnoldi)\n", esolver->options[LIS_EOPTIONS_ESOLVER]); return LIS_ERR_ILL_ARG; } ss = esolver->options[LIS_EOPTIONS_SUBSPACE]; lis_esolver_evector_size = esolver->evector[0]->gn; lis_matrix_set_size(M,0,lis_esolver_evector_size); lis_matrix_get_size(M,&n,&gn); lis_matrix_get_range(M,&is,&ie); js=0; if( esolver->evector[0]->origin ) { is++; js++; } for(j=0;j<ss;j++) { for(i=0;i<n;i++) { ii=i+is; jj=j+js; lis_matrix_set_value(LIS_INS_VALUE,ii,jj,esolver->evector[j]->value[i],M); } } lis_matrix_set_type(M,LIS_MATRIX_CSR); lis_matrix_assemble(M); LIS_DEBUG_FUNC_OUT; return LIS_SUCCESS; }
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_matrix_copy_dia(LIS_MATRIX Ain, LIS_MATRIX Aout) { LIS_INT err; LIS_INT i,n,nnd,lnnd,unnd; LIS_INT *index; LIS_INT *lindex; LIS_INT *uindex; LIS_SCALAR *value,*lvalue,*uvalue,*diag; LIS_DEBUG_FUNC_IN; n = Ain->n; if( Ain->is_splited ) { lnnd = Ain->L->nnd; unnd = Ain->U->nnd; lindex = NULL; uindex = NULL; diag = NULL; err = lis_matrix_malloc_dia(n,lnnd,&lindex,&lvalue); if( err ) { return err; } err = lis_matrix_malloc_dia(n,unnd,&uindex,&uvalue); if( err ) { lis_free2(5,diag,uindex,lindex,uvalue,lvalue); return err; } diag = (LIS_SCALAR *)lis_malloc(n*sizeof(LIS_SCALAR),"lis_matrix_copy_dia::diag"); if( diag==NULL ) { lis_free2(5,diag,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_dia(n,lnnd,Ain->L->index,Ain->L->value,lindex,lvalue); lis_matrix_elements_copy_dia(n,unnd,Ain->U->index,Ain->U->value,uindex,uvalue); err = lis_matrix_setDLU_dia(lnnd,unnd,diag,lindex,lvalue,uindex,uvalue,Aout); if( err ) { lis_free2(5,diag,uindex,lindex,uvalue,lvalue); return err; } } if( !Ain->is_splited || (Ain->is_splited && Ain->is_save) ) { index = NULL; value = NULL; nnd = Ain->nnd; err = lis_matrix_malloc_dia(n,nnd,&index,&value); if( err ) { return err; } lis_matrix_elements_copy_dia(n,nnd,Ain->index,Ain->value,index,value); err = lis_matrix_set_dia(nnd,index,value,Aout); if( err ) { lis_free2(2,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; }
LIS_INT lis_input_hb_csr(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, FILE *file) { char buf[BUFSIZE]; char title[128], key[128], mtx[64], dat[128]; char *p; char MXTYPE_F,MXTYPE_S,MXTYPE_T; char RHSTYP_F,RHSTYP_S,RHSTYP_T; LIS_INT TOTCRD,PTRCRD,INDCRD,VALCRD,RHSCRD; LIS_INT NROW,NCOL,NNZERO,NELTVL; LIS_INT NRHS,NRHSIX; LIS_INT iptr,iind,ival,irhs; LIS_INT wptr,wind,wval,wrhs; LIS_INT i,k,j,my_rank; LIS_INT err; LIS_INT n,is,ie; LIS_INT *ptr, *index; LIS_INT matrix_type; LIS_SCALAR *value; LIS_MATRIX B; #ifdef USE_MPI MPI_Comm_rank(A->comm,&my_rank); #else my_rank = 0; #endif matrix_type = A->matrix_type; /* Line 1 */ if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } strncpy(title, buf ,72); title[72] = '\0'; strncpy(key ,&buf[72], 8); key[8] = '\0'; printf("title: %s\n",title); printf("key : %s\n",key); /* Line 2 */ if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } #ifdef _LONGLONG if( sscanf(buf, "%14lld%14lld%14lld%14lld%14lld", &TOTCRD, &PTRCRD, &INDCRD, &VALCRD, &RHSCRD) != 5 ) #else if( sscanf(buf, "%14d%14d%14d%14d%14d", &TOTCRD, &PTRCRD, &INDCRD, &VALCRD, &RHSCRD) != 5 ) #endif { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } #ifdef _LONGLONG printf("%14lld%14lld%14lld%14lld%14lld\n",TOTCRD, PTRCRD, INDCRD, VALCRD, RHSCRD); #else printf("%14d%14d%14d%14d%14d\n",TOTCRD, PTRCRD, INDCRD, VALCRD, RHSCRD); #endif /* Line 3 */ if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } #ifdef _LONGLONG if( sscanf(buf, "%s %lld %lld %lld %lld", mtx, &NROW, &NCOL, &NNZERO, &NELTVL) != 5 ) #else if( sscanf(buf, "%s %d %d %d %d", mtx, &NROW, &NCOL, &NNZERO, &NELTVL) != 5 ) #endif { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } for(p=mtx;*p!='\0';p++) *p = (char)tolower(*p); MXTYPE_F = mtx[0]; MXTYPE_S = mtx[1]; MXTYPE_T = mtx[2]; if( mtx[0]!='r' ) { LIS_SETERR(LIS_ERR_FILE_IO,"Not real\n"); return LIS_ERR_FILE_IO; } /* if( mtx[1]!='u' ) { LIS_SETERR(LIS_ERR_FILE_IO,"Not unsymmetric\n"); return LIS_ERR_FILE_IO; } */ if( mtx[2]!='a' ) { LIS_SETERR(LIS_ERR_FILE_IO,"Not assembled\n"); return LIS_ERR_FILE_IO; } if( NROW!=NCOL ) { LIS_SETERR(LIS_ERR_FILE_IO,"matrix is not square\n"); return LIS_ERR_FILE_IO; } #ifdef _LONGLONG printf("%c%c%c %lld %lld %lld %lld\n",MXTYPE_F, MXTYPE_S, MXTYPE_T, NROW, NCOL, NNZERO, NELTVL); #else printf("%c%c%c %d %d %d %d\n",MXTYPE_F, MXTYPE_S, MXTYPE_T, NROW, NCOL, NNZERO, NELTVL); #endif /* Line 4 */ if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } lis_input_hb_get_fmt( buf ,16,&iptr,&wptr); lis_input_hb_get_fmt(&buf[16],16,&iind,&wind); lis_input_hb_get_fmt(&buf[32],20,&ival,&wval); lis_input_hb_get_fmt(&buf[52],20,&irhs,&wrhs); #ifdef _LONGLONG printf("%lld %lld %lld %lld\n",iptr,iind,ival,irhs); printf("%lld %lld %lld %lld\n",wptr,wind,wval,wrhs); #else printf("%d %d %d %d\n",iptr,iind,ival,irhs); printf("%d %d %d %d\n",wptr,wind,wval,wrhs); #endif /* Line 5 */ if( RHSCRD!=0 ) { if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } #ifdef _LONGLONG sscanf(buf, "%s %lld %lld", mtx, &NRHS, &NRHSIX); #else sscanf(buf, "%s %d %d", mtx, &NRHS, &NRHSIX); #endif /* #ifdef _LONGLONG if( sscanf(buf, "%s %lld %lld", mtx, &NRHS, &NRHSIX) != 3 ) #else if( sscanf(buf, "%s %d %d", mtx, &NRHS, &NRHSIX) != 3 ) #endif { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } */ for(p=mtx;*p!='\0';p++) *p = (char)tolower(*p); RHSTYP_F = mtx[0]; RHSTYP_S = mtx[1]; RHSTYP_T = mtx[2]; #ifdef _LONGLONG printf("%c%c%c %lld %lld\n",RHSTYP_F, RHSTYP_S, RHSTYP_T, NRHS, NRHSIX); #else printf("%c%c%c %d %d\n",RHSTYP_F, RHSTYP_S, RHSTYP_T, NRHS, NRHSIX); #endif } err = lis_matrix_set_size(A,0,NROW); if( err ) { return err; } n = A->n; lis_matrix_get_range(A,&is,&ie); err = lis_matrix_malloc_csr(n,NNZERO,&ptr,&index,&value); if( err ) { return err; } /* read data */ k = 0; for( i=0; i<PTRCRD; i++ ) { if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } p = buf; for(j=0;j<iptr&&k<n+1;j++) { strncpy(dat, p, wptr); dat[wptr] = '\0'; ptr[k] = atoi(dat) - 1; p += wptr; k++; } } k = 0; for( i=0; i<INDCRD; i++ ) { if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } p = buf; for(j=0;j<iind&&k<NNZERO;j++) { strncpy(dat, p, wind); dat[wind] = '\0'; index[k] = atoi(dat) - 1; p += wind; k++; } } k = 0; for( i=0; i<VALCRD; i++ ) { if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } p = buf; for(j=0;j<ival&&k<NNZERO;j++) { strncpy(dat, p, wval); dat[wval] = '\0'; value[k] = atof(dat); p += wval; k++; } } if( RHSCRD>0 ) { /* k = 0; for( i=0; i<RHSCRD; i++ ) { if( fgets(buf, BUFSIZE, file) == NULL ) { LIS_SETERR_FIO; return LIS_ERR_FILE_IO; } p = buf; for(j=0;j<ival&&k<NNZERO;j++) { strncpy(dat, p, wval); dat[wval] = '\0'; value[k] = atof(dat); p += wval; printf("%e ",value[k]); k++; } printf("\n"); } */ } err = lis_matrix_set_csc(NNZERO,ptr,index,value,A); if( err ) { return err; } err = lis_matrix_assemble(A); if( err ) return err; if( matrix_type!=LIS_MATRIX_CSC ) { err = lis_matrix_duplicate(A,&B); if( err ) return err; lis_matrix_set_type(B,LIS_MATRIX_CSR); err = lis_matrix_convert_csc2csr(A,B); if( err ) return err; lis_matrix_storage_destroy(A); lis_matrix_DLU_destroy(A); lis_matrix_diag_destroy(A->WD); if( A->l2g_map ) lis_free( A->l2g_map ); if( A->commtable ) lis_commtable_destroy( A->commtable ); if( A->ranges ) lis_free( A->ranges ); err = lis_matrix_copy_struct(B,A); if( err ) return err; lis_free(B); } return LIS_SUCCESS; }
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 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_csr2msr(LIS_MATRIX Ain, LIS_MATRIX Aout) { LIS_INT i,j,k,jj; LIS_INT err; LIS_INT n,nnz,ndz; LIS_INT count; LIS_INT *iw; LIS_INT *index; LIS_SCALAR *value; LIS_DEBUG_FUNC_IN; n = Ain->n; nnz = Ain->nnz; iw = NULL; index = NULL; value = NULL; iw = (LIS_INT *)lis_malloc( (n+1)*sizeof(LIS_INT),"lis_matrix_convert_csr2msr::iw" ); if( iw==NULL ) { LIS_SETERR_MEM((n+1)*sizeof(LIS_INT)); return LIS_ERR_OUT_OF_MEMORY; } /* check ndz */ for(i=0;i<n+1;i++) iw[i] = 0; count = 0; #ifdef _OPENMP #pragma omp parallel private(i,j) #endif { #ifdef _OPENMP #pragma omp for #endif for(i=0;i<n;i++) { iw[i+1] = 0; for(j=Ain->ptr[i];j<Ain->ptr[i+1];j++) { if( i==Ain->index[j] ) { iw[i+1] = 1; } } } #ifdef _OPENMP #pragma omp for reduction(+:count) #endif for(i=0;i<n;i++) { count += iw[i+1]; } #ifdef _OPENMP #pragma omp for #endif for(i=0;i<n;i++) { iw[i+1] = Ain->ptr[i+1]-Ain->ptr[i]-iw[i+1]; } } ndz = n - count; err = lis_matrix_malloc_msr(n,nnz,ndz,&index,&value); if( err ) { lis_free2(3,index,value,iw); return err; } /* convert msr */ iw[0] = n+1; for(i=0;i<n;i++) { iw[i+1] = iw[i+1] + iw[i]; } #ifdef _OPENMP #pragma omp parallel private(i,j,k) #endif { #ifdef _OPENMP #pragma omp for #endif for(i=0;i<n+1;i++) { index[i] = iw[i]; } #ifdef _OPENMP #pragma omp for #endif for(i=0;i<n;i++) { k = index[i]; for(j=Ain->ptr[i];j<Ain->ptr[i+1];j++) { jj = Ain->index[j]; if( jj==i ) { value[i] = Ain->value[j]; } else { value[k] = Ain->value[j]; index[k] = Ain->index[j]; k++; } } } } err = lis_matrix_set_msr(nnz,ndz,index,value,Aout); if( err ) { lis_free2(3,index,value,iw); return err; } err = lis_matrix_assemble(Aout); if( err ) { lis_free(iw); lis_matrix_storage_destroy(Aout); return err; } lis_free(iw); 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_rco2csc(LIS_MATRIX Ain, LIS_MATRIX Aout) { LIS_INT i,j,k,l,n,nnz,err; LIS_INT *ptr,*index,*iw; LIS_SCALAR *value; LIS_DEBUG_FUNC_IN; ptr = NULL; index = NULL; value = NULL; iw = NULL; n = Ain->n; iw = (LIS_INT *)lis_malloc(n*sizeof(LIS_INT),"lis_matrix_convert_rco2csc::iw"); if( iw==NULL ) { LIS_SETERR_MEM(n*sizeof(LIS_INT)); lis_free2(4,ptr,index,value,iw); return LIS_OUT_OF_MEMORY; } ptr = (LIS_INT *)lis_malloc((n+1)*sizeof(LIS_INT),"lis_matrix_convert_rco2csc::ptr"); if( ptr==NULL ) { LIS_SETERR_MEM((n+1)*sizeof(LIS_INT)); lis_free2(4,ptr,index,value,iw); return LIS_OUT_OF_MEMORY; } for(i=0;i<n;i++) iw[i] = 0; for(i=0;i<n;i++) { for(j=0;j<Ain->w_row[i];j++) { iw[Ain->w_index[i][j]]++; } } ptr[0] = 0; for(i=0;i<n;i++) { ptr[i+1] = ptr[i] + iw[i]; iw[i] = ptr[i]; } nnz = ptr[n]; index = (LIS_INT *)lis_malloc( nnz*sizeof(LIS_INT),"lis_matrix_convert_rco2csc::index" ); if( index==NULL ) { LIS_SETERR_MEM(nnz*sizeof(LIS_INT)); lis_free2(4,ptr,index,value,iw); return LIS_OUT_OF_MEMORY; } value = (LIS_SCALAR *)lis_malloc( nnz*sizeof(LIS_SCALAR),"lis_matrix_convert_rco2csc::value" ); if( value==NULL ) { LIS_SETERR_MEM(nnz*sizeof(LIS_SCALAR)); lis_free2(4,ptr,index,value,iw); return LIS_OUT_OF_MEMORY; } for(i=0;i<n;i++) { for(j=0;j<Ain->w_row[i];j++) { k = Ain->w_index[i][j]; l = iw[k]; value[l] = Ain->w_value[i][j]; index[l] = i; iw[k]++; } } err = lis_matrix_set_csc(nnz,ptr,index,value,Aout); if( err ) { lis_free2(4,ptr,index,value,iw); return err; } err = lis_matrix_assemble(Aout); if( err ) { lis_matrix_storage_destroy(Aout); return err; } lis_free(iw); LIS_DEBUG_FUNC_OUT; return LIS_SUCCESS; }
LIS_INT lis_matrix_convert_rco2bsr(LIS_MATRIX Ain, LIS_MATRIX Aout) { LIS_INT i,j,k,n,gn,nnz,bnnz,nr,nc,bnr,bnc,err; LIS_INT ii,jj,kk,bj,jpos,ij,kv,bi; LIS_INT *iw,*iw2; LIS_INT *bptr,*bindex; LIS_SCALAR *value; LIS_DEBUG_FUNC_IN; bnr = Ain->conv_bnr; bnc = Ain->conv_bnc; n = Ain->n; gn = Ain->gn; nr = 1 + (n-1)/bnr; nc = 1 + (gn-1)/bnc; bptr = NULL; bindex = NULL; value = NULL; iw = NULL; iw2 = NULL; bptr = (LIS_INT *)lis_malloc( (nr+1)*sizeof(LIS_INT),"lis_matrix_convert_rco2bsr::bptr" ); if( bptr==NULL ) { LIS_SETERR_MEM((nr+1)*sizeof(LIS_INT)); lis_free2(5,bptr,bindex,value,iw,iw2); return LIS_OUT_OF_MEMORY; } #ifdef _OPENMP #pragma omp parallel private(i,k,ii,j,bj,kk,ij,jj,iw,iw2,kv,jpos) #endif { iw = (LIS_INT *)lis_malloc( nc*sizeof(LIS_INT),"lis_matrix_convert_rco2bsr::iw" ); iw2 = (LIS_INT *)lis_malloc( nc*sizeof(LIS_INT),"lis_matrix_convert_rco2bsr::iw2" ); memset(iw,0,nc*sizeof(LIS_INT)); #ifdef _OPENMP #pragma omp for #endif for(i=0;i<nr;i++) { k = 0; kk = bnr*i; jj = 0; for(ii=0;ii+kk<n&&ii<bnr;ii++) { for(j=0;j<Ain->w_row[kk+ii];j++) { bj = Ain->w_index[kk+ii][j]/bnc; jpos = iw[bj]; if( jpos==0 ) { iw[bj] = 1; iw2[jj] = bj; jj++; } } } for(bj=0;bj<jj;bj++) { k++; ii = iw2[bj]; iw[ii]=0; } bptr[i+1] = k; } lis_free(iw); lis_free(iw2); } bptr[0] = 0; for(i=0;i<nr;i++) { bptr[i+1] += bptr[i]; } bnnz = bptr[nr]; nnz = bnnz*bnr*bnc; bindex = (LIS_INT *)lis_malloc( bnnz*sizeof(LIS_INT),"lis_matrix_convert_rco2bsr::bindex" ); if( bindex==NULL ) { LIS_SETERR_MEM((nr+1)*sizeof(LIS_INT)); lis_free2(3,bptr,bindex,value); return LIS_OUT_OF_MEMORY; } value = (LIS_SCALAR *)lis_malloc( nnz*sizeof(LIS_SCALAR),"lis_matrix_convert_rco2bsr::value" ); if( value==NULL ) { LIS_SETERR_MEM(nnz*sizeof(LIS_SCALAR)); lis_free2(3,bptr,bindex,value); return LIS_OUT_OF_MEMORY; } /* convert bsr */ #ifdef _OPENMP #pragma omp parallel private(bi,i,ii,k,j,bj,jpos,kv,kk,ij,jj,iw) #endif { iw = (LIS_INT *)lis_malloc( nc*sizeof(LIS_INT),"lis_matrix_convert_rco2bsr::iw" ); memset(iw,0,nc*sizeof(LIS_INT)); #ifdef _OPENMP #pragma omp for #endif for(bi=0;bi<nr;bi++) { i = bi*bnr; ii = 0; kk = bptr[bi]; while( i+ii<n && ii<=bnr-1 ) { for( k=0;k<Ain->w_row[i+ii];k++) { j = Ain->w_index[i+ii][k]; bj = j/bnc; j = j%bnc; jpos = iw[bj]; if( jpos==0 ) { kv = kk * bnr * bnc; iw[bj] = kv+1; bindex[kk] = bj; for(jj=0;jj<bnr*bnc;jj++) value[kv+jj] = 0.0; ij = j*bnr + ii; value[kv+ij] = Ain->w_value[i+ii][k]; kk = kk+1; } else { ij = j*bnr + ii; value[jpos+ij-1] = Ain->w_value[i+ii][k]; } } ii = ii+1; } for(j=bptr[bi];j<bptr[bi+1];j++) { iw[bindex[j]] = 0; } } lis_free(iw); } err = lis_matrix_set_bsr(bnr,bnc,bnnz,bptr,bindex,value,Aout); if( err ) { lis_free2(3,bptr,bindex,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 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 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; }
int solveLis(DATA *data, threadData_t *threadData, int sysNumber) { void *dataAndThreadData[2] = {data, threadData}; LINEAR_SYSTEM_DATA* systemData = &(data->simulationInfo->linearSystemData[sysNumber]); DATA_LIS* solverData = (DATA_LIS*)systemData->solverData; int i, ret, success = 1, ni, iflag = 1, n = systemData->size, eqSystemNumber = systemData->equationIndex; char *lis_returncode[] = {"LIS_SUCCESS", "LIS_ILL_OPTION", "LIS_BREAKDOWN", "LIS_OUT_OF_MEMORY", "LIS_MAXITER", "LIS_NOT_IMPLEMENTED", "LIS_ERR_FILE_IO"}; LIS_INT err; int indexes[2] = {1,eqSystemNumber}; infoStreamPrintWithEquationIndexes(LOG_LS, 0, indexes, "Start solving Linear System %d (size %d) at time %g with Lis Solver", eqSystemNumber, (int) systemData->size, data->localData[0]->timeValue); /* set old values as start value for the iteration */ for(i=0; i<n; i++) { err = lis_vector_set_value(LIS_INS_VALUE, i, systemData->x[i], solverData->x); } rt_ext_tp_tick(&(solverData->timeClock)); if (0 == systemData->method) { lis_matrix_set_size(solverData->A, solverData->n_row, 0); /* set A matrix */ systemData->setA(data, threadData, systemData); lis_matrix_assemble(solverData->A); /* set b vector */ systemData->setb(data, threadData, systemData); } else { lis_matrix_set_size(solverData->A, solverData->n_row, 0); /* calculate jacobian -> matrix A*/ if(systemData->jacobianIndex != -1) { getAnalyticalJacobianLis(data, threadData, sysNumber); } else { assertStreamPrint(threadData, 1, "jacobian function pointer is invalid" ); } lis_matrix_assemble(solverData->A); /* calculate vector b (rhs) */ memcpy(solverData->work, systemData->x, sizeof(double)*solverData->n_row); wrapper_fvec_lis(solverData->work, systemData->b, dataAndThreadData, sysNumber); /* set b vector */ for(i=0; i<n; i++) { err = lis_vector_set_value(LIS_INS_VALUE, i, systemData->b[i], solverData->b); } } infoStreamPrint(LOG_LS, 0, "### %f time to set Matrix A and vector b.", rt_ext_tp_tock(&(solverData->timeClock))); rt_ext_tp_tick(&(solverData->timeClock)); err = lis_solve(solverData->A,solverData->b,solverData->x,solverData->solver); infoStreamPrint(LOG_LS, 0, "Solve System: %f", rt_ext_tp_tock(&(solverData->timeClock))); if (err) { warningStreamPrint(LOG_LS_V, 0, "lis_solve : %s(code=%d)\n\n ", lis_returncode[err], err); printLisMatrixCSR(solverData->A, solverData->n_row); success = 0; } /* Log A*x=b */ if(ACTIVE_STREAM(LOG_LS_V)) { char *buffer = (char*)malloc(sizeof(char)*n*25); printLisMatrixCSR(solverData->A, n); /* b vector */ infoStreamPrint(LOG_LS_V, 1, "b vector [%d]", n); for(i=0; i<n; i++) { buffer[0] = 0; sprintf(buffer, "%s%20.12g ", buffer, solverData->b->value[i]); infoStreamPrint(LOG_LS_V, 0, "%s", buffer); } messageClose(LOG_LS_V); free(buffer); } /* print solution */ if (1 == success) { if (1 == systemData->method) { /* take the solution */ lis_vector_get_values(solverData->x, 0, solverData->n_row, systemData->x); for(i = 0; i < solverData->n_row; ++i) systemData->x[i] += solverData->work[i]; /* update inner equations */ wrapper_fvec_lis(systemData->x, solverData->work, dataAndThreadData, sysNumber); } else { /* write solution */ lis_vector_get_values(solverData->x, 0, solverData->n_row, systemData->x); } if (ACTIVE_STREAM(LOG_LS_V)) { infoStreamPrint(LOG_LS_V, 1, "Solution x:"); infoStreamPrint(LOG_LS_V, 0, "System %d numVars %d.", eqSystemNumber, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).numVar); for(i = 0; i < systemData->size; ++i) infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).vars[i], systemData->x[i]); messageClose(LOG_LS_V); } } else { warningStreamPrint(LOG_STDOUT, 0, "Failed to solve linear system of equations (no. %d) at time %f, system status %d.", (int)systemData->equationIndex, data->localData[0]->timeValue, err); } return success; }