extern "C" magma_int_t magma_z_mtranspose( magma_z_sparse_matrix A, magma_z_sparse_matrix *B, magma_queue_t queue ) { magma_z_cucsrtranspose( A, B, queue ); return MAGMA_SUCCESS; }
magma_int_t magma_zinitguess( magma_z_matrix A, magma_z_matrix *L, magma_z_matrix *U, magma_queue_t queue ) { magma_int_t info = 0; magmaDoubleComplex one = MAGMA_Z_MAKE( 1.0, 0.0 ); magma_z_matrix hAL={Magma_CSR}, hAU={Magma_CSR}, dAL={Magma_CSR}, dAU={Magma_CSR}, dALU={Magma_CSR}, hALU={Magma_CSR}, hD={Magma_CSR}, dD={Magma_CSR}, dL={Magma_CSR}, hL={Magma_CSR}; magma_int_t i,j; magma_int_t offdiags = 0; magma_index_t *diag_offset; magmaDoubleComplex *diag_vals=NULL; // need only lower triangular hAL.diagorder_type = Magma_VALUE; CHECK( magma_zmconvert( A, &hAL, Magma_CSR, Magma_CSRL, queue )); //magma_zmconvert( hAL, &hALCOO, Magma_CSR, Magma_CSRCOO ); // need only upper triangular //magma_zmconvert( A, &hAU, Magma_CSR, Magma_CSRU ); CHECK( magma_z_cucsrtranspose( hAL, &hAU, queue )); //magma_zmconvert( hAU, &hAUCOO, Magma_CSR, Magma_CSRCOO ); CHECK( magma_zmtransfer( hAL, &dAL, Magma_CPU, Magma_DEV, queue )); CHECK( magma_z_spmm( one, dAL, dAU, &dALU, queue )); CHECK( magma_zmtransfer( dALU, &hALU, Magma_DEV, Magma_CPU, queue )); magma_zmfree( &dAU, queue); magma_zmfree( &dALU, queue); CHECK( magma_zmalloc_cpu( &diag_vals, offdiags+1 )); CHECK( magma_index_malloc_cpu( &diag_offset, offdiags+1 )); diag_offset[0] = 0; diag_vals[0] = MAGMA_Z_MAKE( 1.0, 0.0 ); CHECK( magma_zmgenerator( hALU.num_rows, offdiags, diag_offset, diag_vals, &hD, queue )); magma_zmfree( &hALU, queue ); for(i=0; i<hALU.num_rows; i++){ for(j=hALU.row[i]; j<hALU.row[i+1]; j++){ if( hALU.col[j] == i ){ //printf("%d %d %d == %d -> %f -->", i, j, hALU.col[j], i, hALU.val[j]); hD.val[i] = MAGMA_Z_MAKE( 1.0 / sqrt(fabs(MAGMA_Z_REAL(hALU.val[j]))) , 0.0 ); //printf("insert %f at %d\n", hD.val[i], i); } } } CHECK( magma_zmtransfer( hD, &dD, Magma_CPU, Magma_DEV, queue )); magma_zmfree( &hD, queue); CHECK( magma_z_spmm( one, dD, dAL, &dL, queue )); magma_zmfree( &dAL, queue ); magma_zmfree( &dD, queue ); /* // check for diagonal = 1 magma_z_matrix dLt={Magma_CSR}, dLL={Magma_CSR}, LL={Magma_CSR}; CHECK( magma_z_cucsrtranspose( dL, &dLt )); CHECK( magma_zcuspmm( dL, dLt, &dLL )); CHECK( magma_zmtransfer( dLL, &LL, Magma_DEV, Magma_CPU )); //for(i=0; i < hALU.num_rows; i++) { for(i=0; i < 100; i++) { for(j=hALU.row[i]; j < hALU.row[i+1]; j++) { if( hALU.col[j] == i ){ printf("%d %d -> %f -->", i, i, LL.val[j]); } } } */ CHECK( magma_zmtransfer( dL, &hL, Magma_DEV, Magma_CPU, queue )); CHECK( magma_zmconvert( hL, L, Magma_CSR, Magma_CSRCOO, queue )); cleanup: if( info !=0 ){ magma_zmfree( L, queue ); magma_zmfree( U, queue ); } magma_zmfree( &dAU, queue); magma_zmfree( &dALU, queue); magma_zmfree( &dL, queue ); magma_zmfree( &hL, queue ); magma_zmfree( &dAL, queue ); magma_zmfree( &dD, queue ); magma_zmfree( &hD, queue); magma_zmfree( &hALU, queue ); return info; }
extern "C" magma_int_t magma_z_cucsrtranspose( magma_z_sparse_matrix A, magma_z_sparse_matrix *B, magma_queue_t queue ) { // for symmetric matrices: convert to csc using cusparse if( A.storage_type == Magma_CSR && A.memory_location == Magma_DEV ) { magma_z_sparse_matrix C; magma_z_mtransfer( A, &C, Magma_DEV, Magma_DEV, queue ); // CUSPARSE context // cusparseHandle_t handle; cusparseStatus_t cusparseStatus; cusparseStatus = cusparseCreate(&handle); cusparseSetStream( handle, queue ); if (cusparseStatus != 0) printf("error in Handle.\n"); cusparseMatDescr_t descrA; cusparseMatDescr_t descrB; cusparseStatus = cusparseCreateMatDescr(&descrA); cusparseStatus = cusparseCreateMatDescr(&descrB); if (cusparseStatus != 0) printf("error in MatrDescr.\n"); cusparseStatus = cusparseSetMatType(descrA,CUSPARSE_MATRIX_TYPE_GENERAL); cusparseSetMatType(descrB,CUSPARSE_MATRIX_TYPE_GENERAL); if (cusparseStatus != 0) printf("error in MatrType.\n"); cusparseStatus = cusparseSetMatIndexBase(descrA,CUSPARSE_INDEX_BASE_ZERO); cusparseSetMatIndexBase(descrB,CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in IndexBase.\n"); cusparseStatus = cusparseZcsr2csc( handle, A.num_rows, A.num_rows, A.nnz, A.dval, A.drow, A.dcol, C.dval, C.dcol, C.drow, CUSPARSE_ACTION_NUMERIC, CUSPARSE_INDEX_BASE_ZERO); if (cusparseStatus != 0) printf("error in transpose: %d.\n", cusparseStatus); cusparseDestroyMatDescr( descrA ); cusparseDestroyMatDescr( descrB ); cusparseDestroy( handle ); magma_z_mtransfer( C, B, Magma_DEV, Magma_DEV, queue ); if( A.fill_mode == Magma_FULL ){ B->fill_mode = Magma_FULL; } else if( A.fill_mode == Magma_LOWER ){ B->fill_mode = Magma_UPPER; } else if ( A.fill_mode == Magma_UPPER ){ B->fill_mode = Magma_LOWER; } // end CUSPARSE context // return MAGMA_SUCCESS; }else if( A.storage_type == Magma_CSR && A.memory_location == Magma_CPU ){ magma_z_sparse_matrix A_d, B_d; magma_z_mtransfer( A, &A_d, A.memory_location, Magma_DEV, queue ); magma_z_cucsrtranspose( A_d, &B_d, queue ); magma_z_mtransfer( B_d, B, Magma_DEV, A.memory_location, queue ); magma_z_mfree( &A_d, queue ); magma_z_mfree( &B_d, queue ); return MAGMA_SUCCESS; }else { magma_z_sparse_matrix ACSR, BCSR; magma_z_mconvert( A, &ACSR, A.storage_type, Magma_CSR, queue ); magma_z_cucsrtranspose( ACSR, &BCSR, queue ); magma_z_mconvert( BCSR, B, Magma_CSR, A.storage_type, queue ); magma_z_mfree( &ACSR, queue ); magma_z_mfree( &BCSR, queue ); return MAGMA_SUCCESS; } }
magma_int_t magma_zailusetup( magma_z_sparse_matrix A, magma_z_preconditioner *precond ){ magma_z_sparse_matrix hAh, hA, hAL, hALCOO, hAU, hAUT, hAUCOO, dAL, dAU, hL, hU, dL, dU, DL, RL, DU, RU; // copy original matrix as CSRCOO to device magma_z_mtransfer(A, &hAh, A.memory_location, Magma_CPU); magma_z_mconvert( hAh, &hA, hAh.storage_type, Magma_CSR ); magma_z_mfree(&hAh); // in case using fill-in magma_zilustruct( &hA, precond->levels); // need only lower triangular hAL.diagorder_type == Magma_UNITY; magma_z_mconvert( hA, &hAL, Magma_CSR, Magma_CSRL ); magma_z_mconvert( hAL, &hALCOO, Magma_CSR, Magma_CSRCOO ); magma_z_mtransfer( hALCOO, &dAL, Magma_CPU, Magma_DEV ); magma_z_mtransfer( hALCOO, &dAU, Magma_CPU, Magma_DEV ); // need only upper triangular magma_z_mconvert( hA, &hAU, Magma_CSR, Magma_CSRU ); magma_z_cucsrtranspose( hAU, &hAUT ); magma_z_mconvert( hAUT, &hAUCOO, Magma_CSR, Magma_CSRCOO ); magma_z_mtransfer( hAUCOO, &dL, Magma_CPU, Magma_DEV ); magma_z_mtransfer( hAUCOO, &dU, Magma_CPU, Magma_DEV ); magma_z_mfree(&hALCOO); magma_z_mfree(&hAL); magma_z_mfree(&hAUCOO); magma_z_mfree(&hAUT); magma_z_mfree(&hAU); for(int i=0; i<precond->sweeps; i++){ magma_zailu_csr_s( dAL, dAU, dL, dU ); } magma_z_mtransfer( dL, &hL, Magma_DEV, Magma_CPU ); magma_z_mtransfer( dU, &hU, Magma_DEV, Magma_CPU ); magma_z_LUmergein( hL, hU, &hA); magma_z_mtransfer( hA, &precond->M, Magma_CPU, Magma_DEV ); magma_z_mfree(&dL); magma_z_mfree(&dU); magma_z_mfree(&dAL); magma_z_mfree(&dAU); hAL.diagorder_type = Magma_UNITY; magma_z_mconvert(hA, &hAL, Magma_CSR, Magma_CSRL); hAL.storage_type = Magma_CSR; magma_z_mconvert(hA, &hAU, Magma_CSR, Magma_CSRU); hAU.storage_type = Magma_CSR; magma_z_mfree(&hA); magma_z_mfree(&hL); magma_z_mfree(&hU); magma_zcsrsplit( 256, hAL, &DL, &RL ); magma_zcsrsplit( 256, hAU, &DU, &RU ); magma_z_mtransfer( DL, &precond->LD, Magma_CPU, Magma_DEV ); magma_z_mtransfer( DU, &precond->UD, Magma_CPU, Magma_DEV ); // for cusparse uncomment this magma_z_mtransfer( hAL, &precond->L, Magma_CPU, Magma_DEV ); magma_z_mtransfer( hAU, &precond->U, Magma_CPU, Magma_DEV ); // for ba-solve uncomment this /* if( RL.nnz != 0 ) magma_z_mtransfer( RL, &precond->L, Magma_CPU, Magma_DEV ); else{ precond->L.nnz = 0; precond->L.val = NULL; precond->L.col = NULL; precond->L.row = NULL; precond->L.blockinfo = NULL; } if( RU.nnz != 0 ) magma_z_mtransfer( RU, &precond->U, Magma_CPU, Magma_DEV ); else{ precond->U.nnz = 0; precond->L.val = NULL; precond->L.col = NULL; precond->L.row = NULL; precond->L.blockinfo = NULL; } */ magma_z_mfree(&hAL); magma_z_mfree(&hAU); magma_z_mfree(&DL); magma_z_mfree(&RL); magma_z_mfree(&DU); magma_z_mfree(&RU); // CUSPARSE context // cusparseHandle_t cusparseHandle; cusparseStatus_t cusparseStatus; cusparseStatus = cusparseCreate(&cusparseHandle); if(cusparseStatus != 0) printf("error in Handle.\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_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 = cusparseZcsrsv_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->L.num_rows, precond->L.nnz, descrL, precond->L.val, precond->L.row, precond->L.col, 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 = cusparseZcsrsv_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->U.num_rows, precond->U.nnz, descrU, precond->U.val, precond->U.row, precond->U.col, precond->cuinfoU ); if(cusparseStatus != 0) printf("error in analysis.\n"); cusparseDestroyMatDescr( descrU ); cusparseDestroy( cusparseHandle ); return MAGMA_SUCCESS; }
magma_int_t magma_zaiccsetup( magma_z_sparse_matrix A, magma_z_preconditioner *precond ){ magma_z_sparse_matrix hAh, hA, hAL, hALCOO, dAL, hL, dL, DL, RL; // copy original matrix as CSRCOO to device magma_z_mtransfer(A, &hAh, A.memory_location, Magma_CPU); magma_z_mconvert( hAh, &hA, hAh.storage_type, Magma_CSR ); magma_z_mfree(&hAh); // in case using fill-in magma_zilustruct( &hA, precond->levels); magma_z_mconvert( hA, &hAL, Magma_CSR, Magma_CSRL ); magma_z_mconvert( hAL, &hALCOO, Magma_CSR, Magma_CSRCOO ); magma_z_mtransfer( hALCOO, &dAL, Magma_CPU, Magma_DEV ); magma_z_mtransfer( hALCOO, &dL, Magma_CPU, Magma_DEV ); magma_z_mfree(&hALCOO); magma_z_mfree(&hAL); magma_z_mfree(&hA); for(int i=0; i<precond->sweeps; i++){ magma_zaic_csr_s( dAL, dL ); } magma_z_mtransfer( dL, &hL, Magma_DEV, Magma_CPU ); magma_z_mfree(&dL); magma_z_mfree(&dAL); magma_z_mconvert(hL, &hAL, hL.storage_type, Magma_CSR); // for CUSPARSE magma_z_mtransfer( hAL, &precond->M, Magma_CPU, Magma_DEV ); magma_zcsrsplit( 256, hAL, &DL, &RL ); magma_z_mtransfer( DL, &precond->LD, Magma_CPU, Magma_DEV ); magma_z_mtransfer( RL, &precond->L, Magma_CPU, Magma_DEV ); magma_z_mfree(&hL); magma_z_cucsrtranspose( hAL, &hL ); magma_zcsrsplit( 256, hL, &DL, &RL ); magma_z_mtransfer( DL, &precond->UD, Magma_CPU, Magma_DEV ); magma_z_mtransfer( RL, &precond->U, Magma_CPU, Magma_DEV ); magma_z_mfree(&hAL); magma_z_mfree(&hL); magma_z_mfree(&DL); magma_z_mfree(&RL); // CUSPARSE context // cusparseHandle_t cusparseHandle; cusparseStatus_t cusparseStatus; cusparseStatus = cusparseCreate(&cusparseHandle); if(cusparseStatus != 0) printf("error in Handle.\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 = cusparseZcsrsv_analysis(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrL, precond->M.val, precond->M.row, precond->M.col, 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 = cusparseZcsrsv_analysis(cusparseHandle, CUSPARSE_OPERATION_TRANSPOSE, precond->M.num_rows, precond->M.nnz, descrU, precond->M.val, precond->M.row, precond->M.col, precond->cuinfoU ); if(cusparseStatus != 0) printf("error in analysis U.\n"); cusparseDestroyMatDescr( descrU ); cusparseDestroy( cusparseHandle ); return MAGMA_SUCCESS; }