void Kokkos::CUSPARSEdetails::CUSPARSESolveAnalysisDestroyer::free(cusparseSolveAnalysisInfo_t *ptr) { cusparseStatus_t status = cusparseDestroySolveAnalysisInfo( *ptr ); delete ptr; TEUCHOS_TEST_FOR_EXCEPTION(status != CUSPARSE_STATUS_SUCCESS, std::runtime_error, "Kokkos::CUSPARSEdetails::CUSPARSESolveAnalysisDestroyer::free(): unknown error.") }
extern "C" magma_int_t magma_dcumiccsetup( magma_d_matrix A, magma_d_preconditioner *precond, magma_queue_t queue ) { magma_int_t info = 0; cusparseHandle_t cusparseHandle=NULL; cusparseMatDescr_t descrA=NULL; cusparseMatDescr_t descrL=NULL; cusparseMatDescr_t descrU=NULL; #if CUDA_VERSION >= 7000 csric02Info_t info_M=NULL; void *pBuffer = NULL; #endif magma_d_matrix hA={Magma_CSR}, hACSR={Magma_CSR}, U={Magma_CSR}; CHECK( magma_dmtransfer( A, &hA, A.memory_location, Magma_CPU, queue )); U.diagorder_type = Magma_VALUE; CHECK( magma_dmconvert( hA, &hACSR, hA.storage_type, Magma_CSR, queue )); // in case using fill-in if( precond->levels > 0 ){ magma_d_matrix hAL={Magma_CSR}, hAUt={Magma_CSR}; CHECK( magma_dsymbilu( &hACSR, precond->levels, &hAL, &hAUt, queue )); magma_dmfree(&hAL, queue); magma_dmfree(&hAUt, queue); } CHECK( magma_dmconvert( hACSR, &U, Magma_CSR, Magma_CSRL, queue )); magma_dmfree( &hACSR, queue ); CHECK( magma_dmtransfer(U, &(precond->M), Magma_CPU, Magma_DEV, queue )); // CUSPARSE context // CHECK_CUSPARSE( cusparseCreate( &cusparseHandle )); CHECK_CUSPARSE( cusparseSetStream( cusparseHandle, queue->cuda_stream() )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrA )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &(precond->cuinfo) )); // use kernel to manually check for zeros n the diagonal CHECK( magma_ddiagcheck( precond->M, queue ) ); #if CUDA_VERSION >= 7000 // this version has the bug fixed where a zero on the diagonal causes a crash CHECK_CUSPARSE( cusparseCreateCsric02Info(&info_M) ); CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_GENERAL )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO )); int buffersize; int structural_zero; int numerical_zero; CHECK_CUSPARSE( cusparseDcsric02_bufferSize( cusparseHandle, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, info_M, &buffersize ) ); CHECK( magma_malloc((void**)&pBuffer, buffersize) ); CHECK_CUSPARSE( cusparseDcsric02_analysis( cusparseHandle, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, info_M, CUSPARSE_SOLVE_POLICY_NO_LEVEL, pBuffer )); CHECK_CUSPARSE( cusparseXcsric02_zeroPivot( cusparseHandle, info_M, &numerical_zero ) ); CHECK_CUSPARSE( cusparseXcsric02_zeroPivot( cusparseHandle, info_M, &structural_zero ) ); CHECK_CUSPARSE( cusparseDcsric02( cusparseHandle, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, info_M, CUSPARSE_SOLVE_POLICY_NO_LEVEL, pBuffer) ); #else // this version contains the bug but is needed for backward compability CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_SYMMETRIC )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrA, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrA, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseDcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo )); CHECK_CUSPARSE( cusparseDcsric0( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo )); #endif CHECK_CUSPARSE( cusparseCreateMatDescr( &descrL )); CHECK_CUSPARSE( cusparseSetMatType( descrL, CUSPARSE_MATRIX_TYPE_TRIANGULAR )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrL, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrL, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrL, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoL )); CHECK_CUSPARSE( cusparseDcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrL, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoL )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrU )); CHECK_CUSPARSE( cusparseSetMatType( descrU, CUSPARSE_MATRIX_TYPE_TRIANGULAR )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrU, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrU, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrU, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoU )); CHECK_CUSPARSE( cusparseDcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrU, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoU )); if( precond->maxiter < 50 ){ //prepare for iterative solves // copy the matrix to precond->L and (transposed) to precond->U CHECK( magma_dmtransfer(precond->M, &(precond->L), Magma_DEV, Magma_DEV, queue )); CHECK( magma_dmtranspose( precond->L, &(precond->U), queue )); // extract the diagonal of L into precond->d CHECK( magma_djacobisetup_diagscal( precond->L, &precond->d, queue )); CHECK( magma_dvinit( &precond->work1, Magma_DEV, hA.num_rows, 1, MAGMA_D_ZERO, queue )); // extract the diagonal of U into precond->d2 CHECK( magma_djacobisetup_diagscal( precond->U, &precond->d2, queue )); CHECK( magma_dvinit( &precond->work2, Magma_DEV, hA.num_rows, 1, MAGMA_D_ZERO, queue )); } /* // to enable also the block-asynchronous iteration for the triangular solves CHECK( magma_dmtransfer( precond->M, &hA, Magma_DEV, Magma_CPU, queue )); hA.storage_type = Magma_CSR; magma_d_matrix hD, hR, hAt CHECK( magma_dcsrsplit( 256, hA, &hD, &hR, queue )); CHECK( magma_dmtransfer( hD, &precond->LD, Magma_CPU, Magma_DEV, queue )); CHECK( magma_dmtransfer( hR, &precond->L, Magma_CPU, Magma_DEV, queue )); magma_dmfree(&hD, queue ); magma_dmfree(&hR, queue ); CHECK( magma_d_cucsrtranspose( hA, &hAt, queue )); CHECK( magma_dcsrsplit( 256, hAt, &hD, &hR, queue )); CHECK( magma_dmtransfer( hD, &precond->UD, Magma_CPU, Magma_DEV, queue )); CHECK( magma_dmtransfer( hR, &precond->U, Magma_CPU, Magma_DEV, queue )); magma_dmfree(&hD, queue ); magma_dmfree(&hR, queue ); magma_dmfree(&hA, queue ); magma_dmfree(&hAt, queue ); */ cleanup: #if CUDA_VERSION >= 7000 magma_free( pBuffer ); cusparseDestroyCsric02Info( info_M ); #endif cusparseDestroySolveAnalysisInfo( precond->cuinfo ); cusparseDestroyMatDescr( descrL ); cusparseDestroyMatDescr( descrU ); cusparseDestroyMatDescr( descrA ); cusparseDestroy( cusparseHandle ); magma_dmfree(&U, queue ); magma_dmfree(&hA, queue ); return info; }
magma_int_t magma_ssolverinfo_free( magma_s_solver_par *solver_par, magma_s_preconditioner *precond_par ){ solver_par->init_res = 0.0; solver_par->iter_res = 0.0; solver_par->final_res = 0.0; if( solver_par->res_vec != NULL ){ magma_free_cpu( solver_par->res_vec ); solver_par->res_vec = NULL; } if( solver_par->timing != NULL ){ magma_free_cpu( solver_par->timing ); solver_par->timing = NULL; } if( solver_par->eigenvectors != NULL ){ magma_free( solver_par->eigenvectors ); solver_par->eigenvectors = NULL; } if( solver_par->eigenvalues != NULL ){ magma_free_cpu( solver_par->eigenvalues ); solver_par->eigenvalues = NULL; } if( precond_par->d.val != NULL ){ magma_free( precond_par->d.val ); precond_par->d.val = NULL; } if( precond_par->M.val != NULL ){ if ( precond_par->M.memory_location == Magma_DEV ) magma_free( precond_par->M.val ); else magma_free_cpu( precond_par->M.val ); precond_par->M.val = NULL; } if( precond_par->M.col != NULL ){ if ( precond_par->M.memory_location == Magma_DEV ) magma_free( precond_par->M.col ); else magma_free_cpu( precond_par->M.col ); precond_par->M.col = NULL; } if( precond_par->M.row != NULL ){ if ( precond_par->M.memory_location == Magma_DEV ) magma_free( precond_par->M.row ); else magma_free_cpu( precond_par->M.row ); precond_par->M.row = NULL; } if( precond_par->M.blockinfo != NULL ){ magma_free_cpu( precond_par->M.blockinfo ); precond_par->M.blockinfo = NULL; } if( precond_par->L.val != NULL ){ if ( precond_par->L.memory_location == Magma_DEV ) magma_free( precond_par->L.val ); else magma_free_cpu( precond_par->L.val ); precond_par->L.val = NULL; } if( precond_par->L.col != NULL ){ if ( precond_par->L.memory_location == Magma_DEV ) magma_free( precond_par->L.col ); else magma_free_cpu( precond_par->L.col ); precond_par->L.col = NULL; } if( precond_par->L.row != NULL ){ if ( precond_par->L.memory_location == Magma_DEV ) magma_free( precond_par->L.row ); else magma_free_cpu( precond_par->L.row ); precond_par->L.row = NULL; } if( precond_par->L.blockinfo != NULL ){ magma_free_cpu( precond_par->L.blockinfo ); precond_par->L.blockinfo = NULL; } if( precond_par->U.val != NULL ){ if ( precond_par->U.memory_location == Magma_DEV ) magma_free( precond_par->U.val ); else magma_free_cpu( precond_par->U.val ); precond_par->U.val = NULL; } if( precond_par->U.col != NULL ){ if ( precond_par->U.memory_location == Magma_DEV ) magma_free( precond_par->U.col ); else magma_free_cpu( precond_par->U.col ); precond_par->U.col = NULL; } if( precond_par->U.row != NULL ){ if ( precond_par->U.memory_location == Magma_DEV ) magma_free( precond_par->U.row ); else magma_free_cpu( precond_par->U.row ); precond_par->U.row = NULL; } if( precond_par->U.blockinfo != NULL ){ magma_free_cpu( precond_par->U.blockinfo ); precond_par->U.blockinfo = NULL; } if( precond_par->solver == Magma_ILU || precond_par->solver == Magma_AILU || precond_par->solver == Magma_ICC|| precond_par->solver == Magma_AICC ){ cusparseStatus_t cusparseStatus; cusparseStatus = cusparseDestroySolveAnalysisInfo( precond_par->cuinfoL ); if(cusparseStatus != 0) printf("error in info-free.\n"); cusparseStatus = cusparseDestroySolveAnalysisInfo( precond_par->cuinfoU ); if(cusparseStatus != 0) printf("error in info-free.\n"); } if( precond_par->LD.val != NULL ){ if ( precond_par->LD.memory_location == Magma_DEV ) magma_free( precond_par->LD.val ); else magma_free_cpu( precond_par->LD.val ); precond_par->LD.val = NULL; } if( precond_par->LD.col != NULL ){ if ( precond_par->LD.memory_location == Magma_DEV ) magma_free( precond_par->LD.col ); else magma_free_cpu( precond_par->LD.col ); precond_par->LD.col = NULL; } if( precond_par->LD.row != NULL ){ if ( precond_par->LD.memory_location == Magma_DEV ) magma_free( precond_par->LD.row ); else magma_free_cpu( precond_par->LD.row ); precond_par->LD.row = NULL; } if( precond_par->LD.blockinfo != NULL ){ magma_free_cpu( precond_par->LD.blockinfo ); precond_par->LD.blockinfo = NULL; } if( precond_par->UD.val != NULL ){ if ( precond_par->UD.memory_location == Magma_DEV ) magma_free( precond_par->UD.val ); else magma_free_cpu( precond_par->UD.val ); precond_par->UD.val = NULL; } if( precond_par->UD.col != NULL ){ if ( precond_par->UD.memory_location == Magma_DEV ) magma_free( precond_par->UD.col ); else magma_free_cpu( precond_par->UD.col ); precond_par->UD.col = NULL; } if( precond_par->UD.row != NULL ){ if ( precond_par->UD.memory_location == Magma_DEV ) magma_free( precond_par->UD.row ); else magma_free_cpu( precond_par->UD.row ); precond_par->UD.row = NULL; } if( precond_par->UD.blockinfo != NULL ){ magma_free_cpu( precond_par->UD.blockinfo ); precond_par->UD.blockinfo = NULL; } precond_par->solver = Magma_NONE; return MAGMA_SUCCESS; }
/* Solve Ax=b using the conjugate gradient method a) without any preconditioning, b) using an Incomplete Cholesky preconditioner and c) using an ILU0 preconditioner. */ int main(int argc, char **argv) { const int max_iter = 1000; int k, M = 0, N = 0, nz = 0, *I = NULL, *J = NULL; int *d_col, *d_row; int qatest = 0; const float tol = 1e-12f; float *x, *rhs; float r0, r1, alpha, beta; float *d_val, *d_x; float *d_zm1, *d_zm2, *d_rm2; float *d_r, *d_p, *d_omega, *d_y; float *val = NULL; float *d_valsILU0; float *valsILU0; float rsum, diff, err = 0.0; float qaerr1, qaerr2 = 0.0; float dot, numerator, denominator, nalpha; const float floatone = 1.0; const float floatzero = 0.0; int nErrors = 0; printf("conjugateGradientPrecond starting...\n"); /* QA testing mode */ if (checkCmdLineFlag(argc, (const char **)argv, "qatest")) { qatest = 1; } /* This will pick the best possible CUDA capable device */ cudaDeviceProp deviceProp; int devID = findCudaDevice(argc, (const char **)argv); printf("GPU selected Device ID = %d \n", devID); if (devID < 0) { printf("Invalid GPU device %d selected, exiting...\n", devID); exit(EXIT_SUCCESS); } checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID)); /* Statistics about the GPU device */ printf("> GPU device has %d Multi-Processors, SM %d.%d compute capabilities\n\n", deviceProp.multiProcessorCount, deviceProp.major, deviceProp.minor); int version = (deviceProp.major * 0x10 + deviceProp.minor); if (version < 0x11) { printf("%s: requires a minimum CUDA compute 1.1 capability\n", sSDKname); // cudaDeviceReset causes the driver to clean up all state. While // not mandatory in normal operation, it is good practice. It is also // needed to ensure correct operation when the application is being // profiled. Calling cudaDeviceReset causes all profile data to be // flushed before the application exits cudaDeviceReset(); exit(EXIT_SUCCESS); } /* Generate a random tridiagonal symmetric matrix in CSR (Compressed Sparse Row) format */ M = N = 16384; nz = 5*N-4*(int)sqrt((double)N); I = (int *)malloc(sizeof(int)*(N+1)); // csr row pointers for matrix A J = (int *)malloc(sizeof(int)*nz); // csr column indices for matrix A val = (float *)malloc(sizeof(float)*nz); // csr values for matrix A x = (float *)malloc(sizeof(float)*N); rhs = (float *)malloc(sizeof(float)*N); for (int i = 0; i < N; i++) { rhs[i] = 0.0; // Initialize RHS x[i] = 0.0; // Initial approximation of solution } genLaplace(I, J, val, M, N, nz, rhs); /* Create CUBLAS context */ cublasHandle_t cublasHandle = 0; cublasStatus_t cublasStatus; cublasStatus = cublasCreate(&cublasHandle); checkCudaErrors(cublasStatus); /* Create CUSPARSE context */ cusparseHandle_t cusparseHandle = 0; cusparseStatus_t cusparseStatus; cusparseStatus = cusparseCreate(&cusparseHandle); checkCudaErrors(cusparseStatus); /* Description of the A matrix*/ cusparseMatDescr_t descr = 0; cusparseStatus = cusparseCreateMatDescr(&descr); checkCudaErrors(cusparseStatus); /* Define the properties of the matrix */ cusparseSetMatType(descr,CUSPARSE_MATRIX_TYPE_GENERAL); cusparseSetMatIndexBase(descr,CUSPARSE_INDEX_BASE_ZERO); /* Allocate required memory */ checkCudaErrors(cudaMalloc((void **)&d_col, nz*sizeof(int))); checkCudaErrors(cudaMalloc((void **)&d_row, (N+1)*sizeof(int))); checkCudaErrors(cudaMalloc((void **)&d_val, nz*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_x, N*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_y, N*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_r, N*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_p, N*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_omega, N*sizeof(float))); cudaMemcpy(d_col, J, nz*sizeof(int), cudaMemcpyHostToDevice); cudaMemcpy(d_row, I, (N+1)*sizeof(int), cudaMemcpyHostToDevice); cudaMemcpy(d_val, val, nz*sizeof(float), cudaMemcpyHostToDevice); cudaMemcpy(d_x, x, N*sizeof(float), cudaMemcpyHostToDevice); cudaMemcpy(d_r, rhs, N*sizeof(float), cudaMemcpyHostToDevice); /* Conjugate gradient without preconditioning. ------------------------------------------ Follows the description by Golub & Van Loan, "Matrix Computations 3rd ed.", Section 10.2.6 */ printf("Convergence of conjugate gradient without preconditioning: \n"); k = 0; r0 = 0; cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, &r1); while (r1 > tol*tol && k <= max_iter) { k++; if (k == 1) { cublasScopy(cublasHandle, N, d_r, 1, d_p, 1); } else { beta = r1/r0; cublasSscal(cublasHandle, N, &beta, d_p, 1); cublasSaxpy(cublasHandle, N, &floatone, d_r, 1, d_p, 1) ; } cusparseScsrmv(cusparseHandle,CUSPARSE_OPERATION_NON_TRANSPOSE, N, N, nz, &floatone, descr, d_val, d_row, d_col, d_p, &floatzero, d_omega); cublasSdot(cublasHandle, N, d_p, 1, d_omega, 1, &dot); alpha = r1/dot; cublasSaxpy(cublasHandle, N, &alpha, d_p, 1, d_x, 1); nalpha = -alpha; cublasSaxpy(cublasHandle, N, &nalpha, d_omega, 1, d_r, 1); r0 = r1; cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, &r1); } printf(" iteration = %3d, residual = %e \n", k, sqrt(r1)); cudaMemcpy(x, d_x, N*sizeof(float), cudaMemcpyDeviceToHost); /* check result */ err = 0.0; for (int i = 0; i < N; i++) { rsum = 0.0; for (int j = I[i]; j < I[i+1]; j++) { rsum += val[j]*x[J[j]]; } diff = fabs(rsum - rhs[i]); if (diff > err) { err = diff; } } printf(" Convergence Test: %s \n", (k <= max_iter) ? "OK" : "FAIL"); nErrors += (k > max_iter) ? 1 : 0; qaerr1 = err; if (0) { // output result in matlab-style array int n=(int)sqrt((double)N); printf("a = [ "); for (int iy=0; iy<n; iy++) { for (int ix=0; ix<n; ix++) { printf(" %f ", x[iy*n+ix]); } if (iy == n-1) { printf(" ]"); } printf("\n"); } } /* Preconditioned Conjugate Gradient using ILU. -------------------------------------------- Follows the description by Golub & Van Loan, "Matrix Computations 3rd ed.", Algorithm 10.3.1 */ printf("\nConvergence of conjugate gradient using incomplete LU preconditioning: \n"); int nzILU0 = 2*N-1; valsILU0 = (float *) malloc(nz*sizeof(float)); checkCudaErrors(cudaMalloc((void **)&d_valsILU0, nz*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_zm1, (N)*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_zm2, (N)*sizeof(float))); checkCudaErrors(cudaMalloc((void **)&d_rm2, (N)*sizeof(float))); /* create the analysis info object for the A matrix */ cusparseSolveAnalysisInfo_t infoA = 0; cusparseStatus = cusparseCreateSolveAnalysisInfo(&infoA); checkCudaErrors(cusparseStatus); /* Perform the analysis for the Non-Transpose case */ cusparseStatus = cusparseScsrsv_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, nz, descr, d_val, d_row, d_col, infoA); checkCudaErrors(cusparseStatus); /* Copy A data to ILU0 vals as input*/ cudaMemcpy(d_valsILU0, d_val, nz*sizeof(float), cudaMemcpyDeviceToDevice); /* generate the Incomplete LU factor H for the matrix A using cudsparseScsrilu0 */ cusparseStatus = cusparseScsrilu0(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, descr, d_valsILU0, d_row, d_col, infoA); checkCudaErrors(cusparseStatus); /* Create info objects for the ILU0 preconditioner */ cusparseSolveAnalysisInfo_t info_u; cusparseCreateSolveAnalysisInfo(&info_u); cusparseMatDescr_t descrL = 0; cusparseStatus = cusparseCreateMatDescr(&descrL); cusparseSetMatType(descrL,CUSPARSE_MATRIX_TYPE_GENERAL); cusparseSetMatIndexBase(descrL,CUSPARSE_INDEX_BASE_ZERO); cusparseSetMatFillMode(descrL, CUSPARSE_FILL_MODE_LOWER); cusparseSetMatDiagType(descrL, CUSPARSE_DIAG_TYPE_UNIT); cusparseMatDescr_t descrU = 0; cusparseStatus = cusparseCreateMatDescr(&descrU); cusparseSetMatType(descrU,CUSPARSE_MATRIX_TYPE_GENERAL); cusparseSetMatIndexBase(descrU,CUSPARSE_INDEX_BASE_ZERO); cusparseSetMatFillMode(descrU, CUSPARSE_FILL_MODE_UPPER); cusparseSetMatDiagType(descrU, CUSPARSE_DIAG_TYPE_NON_UNIT); cusparseStatus = cusparseScsrsv_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, nz, descrU, d_val, d_row, d_col, info_u); /* reset the initial guess of the solution to zero */ for (int i = 0; i < N; i++) { x[i] = 0.0; } checkCudaErrors(cudaMemcpy(d_r, rhs, N*sizeof(float), cudaMemcpyHostToDevice)); checkCudaErrors(cudaMemcpy(d_x, x, N*sizeof(float), cudaMemcpyHostToDevice)); k = 0; cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, &r1); while (r1 > tol*tol && k <= max_iter) { // Forward Solve, we can re-use infoA since the sparsity pattern of A matches that of L cusparseStatus = cusparseScsrsv_solve(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, &floatone, descrL, d_valsILU0, d_row, d_col, infoA, d_r, d_y); checkCudaErrors(cusparseStatus); // Back Substitution cusparseStatus = cusparseScsrsv_solve(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, &floatone, descrU, d_valsILU0, d_row, d_col, info_u, d_y, d_zm1); checkCudaErrors(cusparseStatus); k++; if (k == 1) { cublasScopy(cublasHandle, N, d_zm1, 1, d_p, 1); } else { cublasSdot(cublasHandle, N, d_r, 1, d_zm1, 1, &numerator); cublasSdot(cublasHandle, N, d_rm2, 1, d_zm2, 1, &denominator); beta = numerator/denominator; cublasSscal(cublasHandle, N, &beta, d_p, 1); cublasSaxpy(cublasHandle, N, &floatone, d_zm1, 1, d_p, 1) ; } cusparseScsrmv(cusparseHandle,CUSPARSE_OPERATION_NON_TRANSPOSE, N, N, nzILU0, &floatone, descrU, d_val, d_row, d_col, d_p, &floatzero, d_omega); cublasSdot(cublasHandle, N, d_r, 1, d_zm1, 1, &numerator); cublasSdot(cublasHandle, N, d_p, 1, d_omega, 1, &denominator); alpha = numerator / denominator; cublasSaxpy(cublasHandle, N, &alpha, d_p, 1, d_x, 1); cublasScopy(cublasHandle, N, d_r, 1, d_rm2, 1); cublasScopy(cublasHandle, N, d_zm1, 1, d_zm2, 1); nalpha = -alpha; cublasSaxpy(cublasHandle, N, &nalpha, d_omega, 1, d_r, 1); cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, &r1); } printf(" iteration = %3d, residual = %e \n", k, sqrt(r1)); cudaMemcpy(x, d_x, N*sizeof(float), cudaMemcpyDeviceToHost); /* check result */ err = 0.0; for (int i = 0; i < N; i++) { rsum = 0.0; for (int j = I[i]; j < I[i+1]; j++) { rsum += val[j]*x[J[j]]; } diff = fabs(rsum - rhs[i]); if (diff > err) { err = diff; } } printf(" Convergence Test: %s \n", (k <= max_iter) ? "OK" : "FAIL"); nErrors += (k > max_iter) ? 1 : 0; qaerr2 = err; /* Destroy parameters */ cusparseDestroySolveAnalysisInfo(infoA); cusparseDestroySolveAnalysisInfo(info_u); /* Destroy contexts */ cusparseDestroy(cusparseHandle); cublasDestroy(cublasHandle); /* Free device memory */ free(I); free(J); free(val); free(x); free(rhs); free(valsILU0); cudaFree(d_col); cudaFree(d_row); cudaFree(d_val); cudaFree(d_x); cudaFree(d_y); cudaFree(d_r); cudaFree(d_p); cudaFree(d_omega); cudaFree(d_valsILU0); cudaFree(d_zm1); cudaFree(d_zm2); cudaFree(d_rm2); // cudaDeviceReset causes the driver to clean up all state. While // not mandatory in normal operation, it is good practice. It is also // needed to ensure correct operation when the application is being // profiled. Calling cudaDeviceReset causes all profile data to be // flushed before the application exits cudaDeviceReset(); printf(" Test Summary:\n"); printf(" Counted total of %d errors\n", nErrors); printf(" qaerr1 = %f qaerr2 = %f\n\n", fabs(qaerr1), fabs(qaerr2)); exit((nErrors == 0 &&fabs(qaerr1)<1e-5 && fabs(qaerr2) < 1e-5 ? EXIT_SUCCESS : EXIT_FAILURE)); }
extern "C" magma_int_t magma_dcumilusetup( magma_d_sparse_matrix A, magma_d_preconditioner *precond, magma_queue_t queue ) { //magma_d_mvisu(A, queue ); // copy matrix into preconditioner parameter magma_d_sparse_matrix hA, hACSR; magma_d_mtransfer( A, &hA, A.memory_location, Magma_CPU, queue ); magma_d_mconvert( hA, &hACSR, hA.storage_type, Magma_CSR, queue ); magma_d_mtransfer(hACSR, &(precond->M), Magma_CPU, Magma_DEV, queue ); magma_d_mfree( &hA, queue ); magma_d_mfree( &hACSR, queue ); // CUSPARSE context // cusparseHandle_t cusparseHandle; cusparseStatus_t cusparseStatus; cusparseStatus = cusparseCreate(&cusparseHandle); cusparseSetStream( cusparseHandle, queue ); if (cusparseStatus != 0) printf("error in Handle.\n"); cusparseMatDescr_t descrA; cusparseStatus = cusparseCreateMatDescr(&descrA); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrA,CUSPARSE_MATRIX_TYPE_GENERAL); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatDiagType (descrA, CUSPARSE_DIAG_TYPE_NON_UNIT); if (cusparseStatus != 0) printf("error in DiagType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrA,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseCreateSolveAnalysisInfo( &(precond->cuinfo) ); if (cusparseStatus != 0) printf("error in info.\n"); // end CUSPARSE context // cusparseStatus = cusparseDcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo); if (cusparseStatus != 0) printf("error in analysis:%d\n", cusparseStatus); cusparseStatus = cusparseDcsrilu0( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo); if (cusparseStatus != 0) printf("error in ILU:%d\n", cusparseStatus); cusparseStatus = cusparseDestroySolveAnalysisInfo( precond->cuinfo ); if (cusparseStatus != 0) printf("error in info-free.\n"); cusparseDestroyMatDescr( descrA ); magma_d_sparse_matrix hL, hU; magma_d_mtransfer( precond->M, &hA, Magma_DEV, Magma_CPU, queue ); hL.diagorder_type = Magma_UNITY; magma_d_mconvert( hA, &hL , Magma_CSR, Magma_CSRL, queue ); hU.diagorder_type = Magma_VALUE; magma_d_mconvert( hA, &hU , Magma_CSR, Magma_CSRU, queue ); magma_d_mtransfer( hL, &(precond->L), Magma_CPU, Magma_DEV, queue ); magma_d_mtransfer( hU, &(precond->U), Magma_CPU, Magma_DEV, queue ); cusparseMatDescr_t descrL; cusparseStatus = cusparseCreateMatDescr(&descrL); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrL,CUSPARSE_MATRIX_TYPE_TRIANGULAR); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatDiagType (descrL, CUSPARSE_DIAG_TYPE_UNIT); if (cusparseStatus != 0) printf("error in DiagType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrL,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseSetMatFillMode(descrL,CUSPARSE_FILL_MODE_LOWER); if (cusparseStatus != 0) printf("error in fillmode.\n"); cusparseStatus = cusparseCreateSolveAnalysisInfo(&precond->cuinfoL); if (cusparseStatus != 0) printf("error in info.\n"); cusparseStatus = cusparseDcsrsm_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->L.num_rows, precond->L.nnz, descrL, precond->L.dval, precond->L.drow, precond->L.dcol, precond->cuinfoL ); if (cusparseStatus != 0) printf("error in analysis.\n"); cusparseDestroyMatDescr( descrL ); cusparseMatDescr_t descrU; cusparseStatus = cusparseCreateMatDescr(&descrU); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrU,CUSPARSE_MATRIX_TYPE_TRIANGULAR); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatDiagType (descrU, CUSPARSE_DIAG_TYPE_NON_UNIT); if (cusparseStatus != 0) printf("error in DiagType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrU,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseSetMatFillMode(descrU,CUSPARSE_FILL_MODE_UPPER); if (cusparseStatus != 0) printf("error in fillmode.\n"); cusparseStatus = cusparseCreateSolveAnalysisInfo(&precond->cuinfoU); if (cusparseStatus != 0) printf("error in info.\n"); cusparseStatus = cusparseDcsrsm_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->U.num_rows, precond->U.nnz, descrU, precond->U.dval, precond->U.drow, precond->U.dcol, precond->cuinfoU ); if (cusparseStatus != 0) printf("error in analysis.\n"); cusparseDestroyMatDescr( descrU ); magma_d_mfree(&hA, queue ); magma_d_mfree(&hL, queue ); magma_d_mfree(&hU, queue ); cusparseDestroy( cusparseHandle ); return MAGMA_SUCCESS; }
extern "C" magma_int_t magma_dcumiccsetup( magma_d_sparse_matrix A, magma_d_preconditioner *precond, magma_queue_t queue ) { magma_d_sparse_matrix hA, hACSR, U, hD, hR, hAt; magma_d_mtransfer( A, &hA, A.memory_location, Magma_CPU, queue ); U.diagorder_type = Magma_VALUE; magma_d_mconvert( hA, &hACSR, hA.storage_type, Magma_CSR, queue ); magma_d_mconvert( hACSR, &U, Magma_CSR, Magma_CSRL, queue ); magma_d_mfree( &hACSR, queue ); magma_d_mtransfer(U, &(precond->M), Magma_CPU, Magma_DEV, queue ); // CUSPARSE context // cusparseHandle_t cusparseHandle; cusparseStatus_t cusparseStatus; cusparseStatus = cusparseCreate(&cusparseHandle); cusparseSetStream( cusparseHandle, queue ); if (cusparseStatus != 0) printf("error in Handle.\n"); cusparseMatDescr_t descrA; cusparseStatus = cusparseCreateMatDescr(&descrA); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrA,CUSPARSE_MATRIX_TYPE_SYMMETRIC); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatDiagType (descrA, CUSPARSE_DIAG_TYPE_NON_UNIT); if (cusparseStatus != 0) printf("error in DiagType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrA,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseSetMatFillMode(descrA,CUSPARSE_FILL_MODE_LOWER); if (cusparseStatus != 0) printf("error in fillmode.\n"); cusparseStatus = cusparseCreateSolveAnalysisInfo( &(precond->cuinfo) ); if (cusparseStatus != 0) printf("error in info.\n"); // end CUSPARSE context // cusparseStatus = cusparseDcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo); if (cusparseStatus != 0) printf("error in analysis IC.\n"); cusparseStatus = cusparseDcsric0( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo); cusparseStatus = cusparseDestroySolveAnalysisInfo( precond->cuinfo ); if (cusparseStatus != 0) printf("error in info-free.\n"); if (cusparseStatus != 0) printf("error in ICC.\n"); cusparseMatDescr_t descrL; cusparseStatus = cusparseCreateMatDescr(&descrL); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrL,CUSPARSE_MATRIX_TYPE_TRIANGULAR); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatDiagType (descrL, CUSPARSE_DIAG_TYPE_NON_UNIT); if (cusparseStatus != 0) printf("error in DiagType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrL,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseSetMatFillMode(descrL,CUSPARSE_FILL_MODE_LOWER); if (cusparseStatus != 0) printf("error in fillmode.\n"); cusparseStatus = cusparseCreateSolveAnalysisInfo(&precond->cuinfoL); if (cusparseStatus != 0) printf("error in info.\n"); cusparseStatus = cusparseDcsrsm_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrL, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoL ); if (cusparseStatus != 0) printf("error in analysis L.\n"); cusparseDestroyMatDescr( descrL ); cusparseMatDescr_t descrU; cusparseStatus = cusparseCreateMatDescr(&descrU); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrU,CUSPARSE_MATRIX_TYPE_TRIANGULAR); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatDiagType (descrU, CUSPARSE_DIAG_TYPE_NON_UNIT); if (cusparseStatus != 0) printf("error in DiagType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrU,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseSetMatFillMode(descrU,CUSPARSE_FILL_MODE_LOWER); if (cusparseStatus != 0) printf("error in fillmode.\n"); cusparseStatus = cusparseCreateSolveAnalysisInfo(&precond->cuinfoU); if (cusparseStatus != 0) printf("error in info.\n"); cusparseStatus = cusparseDcsrsm_analysis(cusparseHandle, CUSPARSE_OPERATION_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrU, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoU ); if (cusparseStatus != 0) printf("error in analysis U.\n"); cusparseDestroyMatDescr( descrU ); cusparseDestroyMatDescr( descrA ); cusparseDestroy( cusparseHandle ); magma_d_mfree(&U, queue ); magma_d_mfree(&hA, queue ); /* // to enable also the block-asynchronous iteration for the triangular solves magma_d_mtransfer( precond->M, &hA, Magma_DEV, Magma_CPU, queue ); hA.storage_type = Magma_CSR; magma_dcsrsplit( 256, hA, &hD, &hR, queue ); magma_d_mtransfer( hD, &precond->LD, Magma_CPU, Magma_DEV, queue ); magma_d_mtransfer( hR, &precond->L, Magma_CPU, Magma_DEV, queue ); magma_d_mfree(&hD, queue ); magma_d_mfree(&hR, queue ); magma_d_cucsrtranspose( hA, &hAt, queue ); magma_dcsrsplit( 256, hAt, &hD, &hR, queue ); magma_d_mtransfer( hD, &precond->UD, Magma_CPU, Magma_DEV, queue ); magma_d_mtransfer( hR, &precond->U, Magma_CPU, Magma_DEV, queue ); magma_d_mfree(&hD, queue ); magma_d_mfree(&hR, queue ); magma_d_mfree(&hA, queue ); magma_d_mfree(&hAt, queue ); */ return MAGMA_SUCCESS; }
extern "C" magma_int_t magma_ccumiccsetup( magma_c_matrix A, magma_c_preconditioner *precond, magma_queue_t queue ) { magma_int_t info = 0; cusparseHandle_t cusparseHandle=NULL; cusparseMatDescr_t descrA=NULL; cusparseMatDescr_t descrL=NULL; cusparseMatDescr_t descrU=NULL; magma_c_matrix hA={Magma_CSR}, hACSR={Magma_CSR}, U={Magma_CSR}; CHECK( magma_cmtransfer( A, &hA, A.memory_location, Magma_CPU, queue )); U.diagorder_type = Magma_VALUE; CHECK( magma_cmconvert( hA, &hACSR, hA.storage_type, Magma_CSR, queue )); // in case using fill-in if( precond->levels > 0 ){ magma_c_matrix hAL={Magma_CSR}, hAUt={Magma_CSR}; CHECK( magma_csymbilu( &hACSR, precond->levels, &hAL, &hAUt, queue )); magma_cmfree(&hAL, queue); magma_cmfree(&hAUt, queue); } CHECK( magma_cmconvert( hACSR, &U, Magma_CSR, Magma_CSRL, queue )); magma_cmfree( &hACSR, queue ); CHECK( magma_cmtransfer(U, &(precond->M), Magma_CPU, Magma_DEV, queue )); // CUSPARSE context // CHECK_CUSPARSE( cusparseCreate( &cusparseHandle )); CHECK_CUSPARSE( cusparseSetStream( cusparseHandle, queue )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrA )); CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_SYMMETRIC )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrA, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrA, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &(precond->cuinfo) )); CHECK_CUSPARSE( cusparseCcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo )); CHECK_CUSPARSE( cusparseCcsric0( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrL )); CHECK_CUSPARSE( cusparseSetMatType( descrL, CUSPARSE_MATRIX_TYPE_TRIANGULAR )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrL, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrL, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrL, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoL )); CHECK_CUSPARSE( cusparseCcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrL, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoL )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrU )); CHECK_CUSPARSE( cusparseSetMatType( descrU, CUSPARSE_MATRIX_TYPE_TRIANGULAR )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrU, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrU, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrU, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoU )); CHECK_CUSPARSE( cusparseCcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrU, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfoU )); if( precond->maxiter < 50 ){ //prepare for iterative solves // copy the matrix to precond->L and (transposed) to precond->U CHECK( magma_cmtransfer(precond->M, &(precond->L), Magma_DEV, Magma_DEV, queue )); CHECK( magma_cmtranspose( precond->L, &(precond->U), queue )); // extract the diagonal of L into precond->d CHECK( magma_cjacobisetup_diagscal( precond->L, &precond->d, queue )); CHECK( magma_cvinit( &precond->work1, Magma_DEV, hA.num_rows, 1, MAGMA_C_ZERO, queue )); // extract the diagonal of U into precond->d2 CHECK( magma_cjacobisetup_diagscal( precond->U, &precond->d2, queue )); CHECK( magma_cvinit( &precond->work2, Magma_DEV, hA.num_rows, 1, MAGMA_C_ZERO, queue )); } /* // to enable also the block-asynchronous iteration for the triangular solves CHECK( magma_cmtransfer( precond->M, &hA, Magma_DEV, Magma_CPU, queue )); hA.storage_type = Magma_CSR; magma_c_matrix hD, hR, hAt CHECK( magma_ccsrsplit( 256, hA, &hD, &hR, queue )); CHECK( magma_cmtransfer( hD, &precond->LD, Magma_CPU, Magma_DEV, queue )); CHECK( magma_cmtransfer( hR, &precond->L, Magma_CPU, Magma_DEV, queue )); magma_cmfree(&hD, queue ); magma_cmfree(&hR, queue ); CHECK( magma_c_cucsrtranspose( hA, &hAt, queue )); CHECK( magma_ccsrsplit( 256, hAt, &hD, &hR, queue )); CHECK( magma_cmtransfer( hD, &precond->UD, Magma_CPU, Magma_DEV, queue )); CHECK( magma_cmtransfer( hR, &precond->U, Magma_CPU, Magma_DEV, queue )); magma_cmfree(&hD, queue ); magma_cmfree(&hR, queue ); magma_cmfree(&hA, queue ); magma_cmfree(&hAt, queue ); */ cleanup: cusparseDestroySolveAnalysisInfo( precond->cuinfo ); cusparseDestroyMatDescr( descrL ); cusparseDestroyMatDescr( descrU ); cusparseDestroyMatDescr( descrA ); cusparseDestroy( cusparseHandle ); magma_cmfree(&U, queue ); magma_cmfree(&hA, queue ); return info; }
extern "C" magma_int_t magma_ccumilusetup( magma_c_matrix A, magma_c_preconditioner *precond, magma_queue_t queue ) { magma_int_t info = 0; cusparseHandle_t cusparseHandle=NULL; cusparseMatDescr_t descrA=NULL; cusparseMatDescr_t descrL=NULL; cusparseMatDescr_t descrU=NULL; //magma_cprint_matrix(A, queue ); // copy matrix into preconditioner parameter magma_c_matrix hA={Magma_CSR}, hACSR={Magma_CSR}; magma_c_matrix hL={Magma_CSR}, hU={Magma_CSR}; CHECK( magma_cmtransfer( A, &hA, A.memory_location, Magma_CPU, queue )); CHECK( magma_cmconvert( hA, &hACSR, hA.storage_type, Magma_CSR, queue )); // in case using fill-in if( precond->levels > 0 ){ magma_c_matrix hAL={Magma_CSR}, hAUt={Magma_CSR}; CHECK( magma_csymbilu( &hACSR, precond->levels, &hAL, &hAUt, queue )); magma_cmfree(&hAL, queue); magma_cmfree(&hAUt, queue); } CHECK( magma_cmtransfer(hACSR, &(precond->M), Magma_CPU, Magma_DEV, queue )); magma_cmfree( &hA, queue ); magma_cmfree( &hACSR, queue ); // CUSPARSE context // CHECK_CUSPARSE( cusparseCreate( &cusparseHandle )); CHECK_CUSPARSE( cusparseSetStream( cusparseHandle, queue )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrA )); CHECK_CUSPARSE( cusparseSetMatType( descrA, CUSPARSE_MATRIX_TYPE_GENERAL )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrA, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrA, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &(precond->cuinfo) )); CHECK_CUSPARSE( cusparseCcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo )); CHECK_CUSPARSE( cusparseCcsrilu0( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, descrA, precond->M.dval, precond->M.drow, precond->M.dcol, precond->cuinfo )); CHECK( magma_cmtransfer( precond->M, &hA, Magma_DEV, Magma_CPU, queue )); hL.diagorder_type = Magma_UNITY; CHECK( magma_cmconvert( hA, &hL , Magma_CSR, Magma_CSRL, queue )); hU.diagorder_type = Magma_VALUE; CHECK( magma_cmconvert( hA, &hU , Magma_CSR, Magma_CSRU, queue )); CHECK( magma_cmtransfer( hL, &(precond->L), Magma_CPU, Magma_DEV, queue )); CHECK( magma_cmtransfer( hU, &(precond->U), Magma_CPU, Magma_DEV, queue )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrL )); CHECK_CUSPARSE( cusparseSetMatType( descrL, CUSPARSE_MATRIX_TYPE_TRIANGULAR )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrL, CUSPARSE_DIAG_TYPE_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrL, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrL, CUSPARSE_FILL_MODE_LOWER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoL )); CHECK_CUSPARSE( cusparseCcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->L.num_rows, precond->L.nnz, descrL, precond->L.dval, precond->L.drow, precond->L.dcol, precond->cuinfoL )); CHECK_CUSPARSE( cusparseCreateMatDescr( &descrU )); CHECK_CUSPARSE( cusparseSetMatType( descrU, CUSPARSE_MATRIX_TYPE_TRIANGULAR )); CHECK_CUSPARSE( cusparseSetMatDiagType( descrU, CUSPARSE_DIAG_TYPE_NON_UNIT )); CHECK_CUSPARSE( cusparseSetMatIndexBase( descrU, CUSPARSE_INDEX_BASE_ZERO )); CHECK_CUSPARSE( cusparseSetMatFillMode( descrU, CUSPARSE_FILL_MODE_UPPER )); CHECK_CUSPARSE( cusparseCreateSolveAnalysisInfo( &precond->cuinfoU )); CHECK_CUSPARSE( cusparseCcsrsm_analysis( cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->U.num_rows, precond->U.nnz, descrU, precond->U.dval, precond->U.drow, precond->U.dcol, precond->cuinfoU )); if( precond->maxiter < 50 ){ //prepare for iterative solves // extract the diagonal of L into precond->d CHECK( magma_cjacobisetup_diagscal( precond->L, &precond->d, queue )); CHECK( magma_cvinit( &precond->work1, Magma_DEV, hA.num_rows, 1, MAGMA_C_ZERO, queue )); // extract the diagonal of U into precond->d2 CHECK( magma_cjacobisetup_diagscal( precond->U, &precond->d2, queue )); CHECK( magma_cvinit( &precond->work2, Magma_DEV, hA.num_rows, 1, MAGMA_C_ZERO, queue )); } cleanup: cusparseDestroySolveAnalysisInfo( precond->cuinfo ); cusparseDestroyMatDescr( descrA ); cusparseDestroyMatDescr( descrL ); cusparseDestroyMatDescr( descrU ); cusparseDestroy( cusparseHandle ); magma_cmfree( &hA, queue ); magma_cmfree( &hACSR, queue ); magma_cmfree(&hA, queue ); magma_cmfree(&hL, queue ); magma_cmfree(&hU, queue ); return info; }
extern "C" magma_int_t magma_dsolverinfo_free( magma_d_solver_par *solver_par, magma_d_preconditioner *precond_par, magma_queue_t queue ) { solver_par->init_res = 0.0; solver_par->iter_res = 0.0; solver_par->final_res = 0.0; if ( solver_par->res_vec != NULL ) { magma_free_cpu( solver_par->res_vec ); solver_par->res_vec = NULL; } if ( solver_par->timing != NULL ) { magma_free_cpu( solver_par->timing ); solver_par->timing = NULL; } if ( solver_par->eigenvectors != NULL ) { magma_free( solver_par->eigenvectors ); solver_par->eigenvectors = NULL; } if ( solver_par->eigenvalues != NULL ) { magma_free_cpu( solver_par->eigenvalues ); solver_par->eigenvalues = NULL; } if ( precond_par->d.val != NULL ) { magma_free( precond_par->d.val ); precond_par->d.val = NULL; } if ( precond_par->d2.val != NULL ) { magma_free( precond_par->d2.val ); precond_par->d2.val = NULL; } if ( precond_par->work1.val != NULL ) { magma_free( precond_par->work1.val ); precond_par->work1.val = NULL; } if ( precond_par->work2.val != NULL ) { magma_free( precond_par->work2.val ); precond_par->work2.val = NULL; } if ( precond_par->M.val != NULL ) { if ( precond_par->M.memory_location == Magma_DEV ) magma_free( precond_par->M.dval ); else magma_free_cpu( precond_par->M.val ); precond_par->M.val = NULL; } if ( precond_par->M.col != NULL ) { if ( precond_par->M.memory_location == Magma_DEV ) magma_free( precond_par->M.dcol ); else magma_free_cpu( precond_par->M.col ); precond_par->M.col = NULL; } if ( precond_par->M.row != NULL ) { if ( precond_par->M.memory_location == Magma_DEV ) magma_free( precond_par->M.drow ); else magma_free_cpu( precond_par->M.row ); precond_par->M.row = NULL; } if ( precond_par->M.blockinfo != NULL ) { magma_free_cpu( precond_par->M.blockinfo ); precond_par->M.blockinfo = NULL; } if ( precond_par->L.val != NULL ) { if ( precond_par->L.memory_location == Magma_DEV ) magma_free( precond_par->L.dval ); else magma_free_cpu( precond_par->L.val ); precond_par->L.val = NULL; } if ( precond_par->L.col != NULL ) { if ( precond_par->L.memory_location == Magma_DEV ) magma_free( precond_par->L.col ); else magma_free_cpu( precond_par->L.dcol ); precond_par->L.col = NULL; } if ( precond_par->L.row != NULL ) { if ( precond_par->L.memory_location == Magma_DEV ) magma_free( precond_par->L.drow ); else magma_free_cpu( precond_par->L.row ); precond_par->L.row = NULL; } if ( precond_par->L.blockinfo != NULL ) { magma_free_cpu( precond_par->L.blockinfo ); precond_par->L.blockinfo = NULL; } if ( precond_par->U.val != NULL ) { if ( precond_par->U.memory_location == Magma_DEV ) magma_free( precond_par->U.dval ); else magma_free_cpu( precond_par->U.val ); precond_par->U.val = NULL; } if ( precond_par->U.col != NULL ) { if ( precond_par->U.memory_location == Magma_DEV ) magma_free( precond_par->U.dcol ); else magma_free_cpu( precond_par->U.col ); precond_par->U.col = NULL; } if ( precond_par->U.row != NULL ) { if ( precond_par->U.memory_location == Magma_DEV ) magma_free( precond_par->U.drow ); else magma_free_cpu( precond_par->U.row ); precond_par->U.row = NULL; } if ( precond_par->U.blockinfo != NULL ) { magma_free_cpu( precond_par->U.blockinfo ); precond_par->U.blockinfo = NULL; } if ( precond_par->solver == Magma_ILU || precond_par->solver == Magma_AILU || precond_par->solver == Magma_ICC|| precond_par->solver == Magma_AICC ) { cusparseDestroySolveAnalysisInfo( precond_par->cuinfoL ); cusparseDestroySolveAnalysisInfo( precond_par->cuinfoU ); precond_par->cuinfoL = NULL; precond_par->cuinfoU = NULL; } if ( precond_par->LD.val != NULL ) { if ( precond_par->LD.memory_location == Magma_DEV ) magma_free( precond_par->LD.dval ); else magma_free_cpu( precond_par->LD.val ); precond_par->LD.val = NULL; } if ( precond_par->LD.col != NULL ) { if ( precond_par->LD.memory_location == Magma_DEV ) magma_free( precond_par->LD.dcol ); else magma_free_cpu( precond_par->LD.col ); precond_par->LD.col = NULL; } if ( precond_par->LD.row != NULL ) { if ( precond_par->LD.memory_location == Magma_DEV ) magma_free( precond_par->LD.drow ); else magma_free_cpu( precond_par->LD.row ); precond_par->LD.row = NULL; } if ( precond_par->LD.blockinfo != NULL ) { magma_free_cpu( precond_par->LD.blockinfo ); precond_par->LD.blockinfo = NULL; } if ( precond_par->UD.val != NULL ) { if ( precond_par->UD.memory_location == Magma_DEV ) magma_free( precond_par->UD.dval ); else magma_free_cpu( precond_par->UD.val ); precond_par->UD.val = NULL; } if ( precond_par->UD.col != NULL ) { if ( precond_par->UD.memory_location == Magma_DEV ) magma_free( precond_par->UD.dcol ); else magma_free_cpu( precond_par->UD.col ); precond_par->UD.col = NULL; } if ( precond_par->UD.row != NULL ) { if ( precond_par->UD.memory_location == Magma_DEV ) magma_free( precond_par->UD.drow ); else magma_free_cpu( precond_par->UD.row ); precond_par->UD.row = NULL; } if ( precond_par->UD.blockinfo != NULL ) { magma_free_cpu( precond_par->UD.blockinfo ); precond_par->UD.blockinfo = NULL; } precond_par->solver = Magma_NONE; return MAGMA_SUCCESS; }