extern "C" magma_int_t
magma_d_mtranspose(
magma_d_sparse_matrix A, magma_d_sparse_matrix *B,
magma_queue_t queue )
{
magma_d_cucsrtranspose( A, B, queue );
return MAGMA_SUCCESS;
}
magma_int_t
magma_dwrite_csr_mtx(
magma_d_matrix A,
magma_order_t MajorType,
const char *filename,
magma_queue_t queue )
{
magma_int_t info = 0;
FILE *fp;
magma_d_matrix B = {Magma_CSR};
if ( MajorType == MagmaColMajor ) {
// to obtain ColMajor output we transpose the matrix
// and flip the row and col pointer in the output
CHECK( magma_d_cucsrtranspose( A, &B, queue ));
// TODO avoid duplicating this code below.
printf("%% Writing sparse matrix to file (%s):", filename);
fflush(stdout);
fp = fopen(filename, "w");
if ( fp == NULL ){
printf("\n%% error writing matrix: file exists or missing write permission\n");
info = -1;
goto cleanup;
}
#define REAL
#ifdef COMPLEX
// real case
fprintf( fp, "%%%%MatrixMarket matrix coordinate real general\n" );
fprintf( fp, "%d %d %d\n", int(B.num_cols), int(B.num_rows), int(B.nnz));
// TODO what's the difference between i (or i+1) and rowindex?
magma_index_t i=0, j=0, rowindex=1;
for(i=0; i < B.num_cols; i++) {
magma_index_t rowtemp1 = B.row[i];
magma_index_t rowtemp2 = B.row[i+1];
for(j=0; j < rowtemp2 - rowtemp1; j++) {
fprintf( fp, "%d %d %.16g %.16g\n",
((B.col)[rowtemp1+j]+1), rowindex,
MAGMA_D_REAL((B.val)[rowtemp1+j]),
MAGMA_D_IMAG((B.val)[rowtemp1+j]) );
}
rowindex++;
}
#else
// real case
fprintf( fp, "%%%%MatrixMarket matrix coordinate real general\n" );
fprintf( fp, "%d %d %d\n", int(B.num_cols), int(B.num_rows), int(B.nnz));
// TODO what's the difference between i (or i+1) and rowindex?
magma_index_t i=0, j=0, rowindex=1;
for(i=0; i < B.num_cols; i++) {
magma_index_t rowtemp1 = B.row[i];
magma_index_t rowtemp2 = B.row[i+1];
for(j=0; j < rowtemp2 - rowtemp1; j++) {
fprintf( fp, "%d %d %.16g\n",
((B.col)[rowtemp1+j]+1), rowindex,
MAGMA_D_REAL((B.val)[rowtemp1+j]) );
}
rowindex++;
}
#endif
if (fclose(fp) != 0)
printf("\n%% error: writing matrix failed\n");
else
printf(" done\n");
}
else {
printf("%% Writing sparse matrix to file (%s):", filename);
fflush(stdout);
fp = fopen (filename, "w");
if ( fp == NULL ){
printf("\n%% error writing matrix: file exists or missing write permission\n");
info = -1;
goto cleanup;
}
#define REAL
#ifdef COMPLEX
// real case
fprintf( fp, "%%%%MatrixMarket matrix coordinate real general\n" );
fprintf( fp, "%d %d %d\n", int(A.num_cols), int(A.num_rows), int(A.nnz));
// TODO what's the difference between i (or i+1) and rowindex?
magma_index_t i=0, j=0, rowindex=1;
for(i=0; i < A.num_cols; i++) {
magma_index_t rowtemp1 = A.row[i];
magma_index_t rowtemp2 = A.row[i+1];
for(j=0; j < rowtemp2 - rowtemp1; j++) {
fprintf( fp, "%d %d %.16g %.16g\n",
((A.col)[rowtemp1+j]+1), rowindex,
MAGMA_D_REAL((A.val)[rowtemp1+j]),
MAGMA_D_IMAG((A.val)[rowtemp1+j]) );
}
rowindex++;
}
#else
// real case
fprintf( fp, "%%%%MatrixMarket matrix coordinate real general\n" );
fprintf( fp, "%d %d %d\n", int(A.num_cols), int(A.num_rows), int(A.nnz));
// TODO what's the difference between i (or i+1) and rowindex?
magma_index_t i=0, j=0, rowindex=1;
for(i=0; i < B.num_cols; i++) {
magma_index_t rowtemp1 = A.row[i];
magma_index_t rowtemp2 = A.row[i+1];
for(j=0; j < rowtemp2 - rowtemp1; j++) {
fprintf( fp, "%d %d %.16g\n",
((A.col)[rowtemp1+j]+1), rowindex,
MAGMA_D_REAL((A.val)[rowtemp1+j]));
}
rowindex++;
}
#endif
if (fclose(fp) != 0)
printf("\n%% error: writing matrix failed\n");
else
printf(" done\n");
}
cleanup:
return info;
}
magma_int_t
magma_dinitguess(
magma_d_matrix A,
magma_d_matrix *L,
magma_d_matrix *U,
magma_queue_t queue )
{
magma_int_t info = 0;
double one = MAGMA_D_MAKE( 1.0, 0.0 );
magma_d_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;
double *diag_vals=NULL;
// need only lower triangular
hAL.diagorder_type = Magma_VALUE;
CHECK( magma_dmconvert( A, &hAL, Magma_CSR, Magma_CSRL, queue ));
//magma_dmconvert( hAL, &hALCOO, Magma_CSR, Magma_CSRCOO );
// need only upper triangular
//magma_dmconvert( A, &hAU, Magma_CSR, Magma_CSRU );
CHECK( magma_d_cucsrtranspose( hAL, &hAU, queue ));
//magma_dmconvert( hAU, &hAUCOO, Magma_CSR, Magma_CSRCOO );
CHECK( magma_dmtransfer( hAL, &dAL, Magma_CPU, Magma_DEV, queue ));
CHECK( magma_d_spmm( one, dAL, dAU, &dALU, queue ));
CHECK( magma_dmtransfer( dALU, &hALU, Magma_DEV, Magma_CPU, queue ));
magma_dmfree( &dAU, queue);
magma_dmfree( &dALU, queue);
CHECK( magma_dmalloc_cpu( &diag_vals, offdiags+1 ));
CHECK( magma_index_malloc_cpu( &diag_offset, offdiags+1 ));
diag_offset[0] = 0;
diag_vals[0] = MAGMA_D_MAKE( 1.0, 0.0 );
CHECK( magma_dmgenerator( hALU.num_rows, offdiags, diag_offset, diag_vals, &hD, queue ));
magma_dmfree( &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_D_MAKE(
1.0 / sqrt(fabs(MAGMA_D_REAL(hALU.val[j]))) , 0.0 );
//printf("insert %f at %d\n", hD.val[i], i);
}
}
}
CHECK( magma_dmtransfer( hD, &dD, Magma_CPU, Magma_DEV, queue ));
magma_dmfree( &hD, queue);
CHECK( magma_d_spmm( one, dD, dAL, &dL, queue ));
magma_dmfree( &dAL, queue );
magma_dmfree( &dD, queue );
/*
// check for diagonal = 1
magma_d_matrix dLt={Magma_CSR}, dLL={Magma_CSR}, LL={Magma_CSR};
CHECK( magma_d_cucsrtranspose( dL, &dLt ));
CHECK( magma_dcuspmm( dL, dLt, &dLL ));
CHECK( magma_dmtransfer( 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_dmtransfer( dL, &hL, Magma_DEV, Magma_CPU, queue ));
CHECK( magma_dmconvert( hL, L, Magma_CSR, Magma_CSRCOO, queue ));
cleanup:
if( info !=0 ){
magma_dmfree( L, queue );
magma_dmfree( U, queue );
}
magma_dmfree( &dAU, queue);
magma_dmfree( &dALU, queue);
magma_dmfree( &dL, queue );
magma_dmfree( &hL, queue );
magma_dmfree( &dAL, queue );
magma_dmfree( &dD, queue );
magma_dmfree( &hD, queue);
magma_dmfree( &hALU, queue );
return info;
}
extern "C" magma_int_t
magma_d_cucsrtranspose(
magma_d_sparse_matrix A,
magma_d_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_d_sparse_matrix C;
magma_d_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 =
cusparseDcsr2csc( 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_d_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_d_sparse_matrix A_d, B_d;
magma_d_mtransfer( A, &A_d, A.memory_location, Magma_DEV, queue );
magma_d_cucsrtranspose( A_d, &B_d, queue );
magma_d_mtransfer( B_d, B, Magma_DEV, A.memory_location, queue );
magma_d_mfree( &A_d, queue );
magma_d_mfree( &B_d, queue );
return MAGMA_SUCCESS;
}else {
magma_d_sparse_matrix ACSR, BCSR;
magma_d_mconvert( A, &ACSR, A.storage_type, Magma_CSR, queue );
magma_d_cucsrtranspose( ACSR, &BCSR, queue );
magma_d_mconvert( BCSR, B, Magma_CSR, A.storage_type, queue );
magma_d_mfree( &ACSR, queue );
magma_d_mfree( &BCSR, queue );
return MAGMA_SUCCESS;
}
}
