/* Copyright (C) 2008-2021 Michele Martone This file is part of librsb. librsb is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. librsb is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with librsb; see the file COPYING. If not, see . */ /* @cond INNERDOC */ /** * @file * @author Michele Martone * @brief Code for matrix format conversion. * */ #include "rsb_common.h" RSB_INTERNALS_COMMON_HEAD_DECLS static rsb_err_t rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo_leaf(struct rsb_mtx_t * mtxAp, rsb_bool_t do_shift) { /** \ingroup gr_internals TODO: move somewhere else TODO: need temporary memory to pass to e.g. rsb__do_switch_compressed_array_to_fullword_coo() and thus avoid allocations. // to free the unnecessary data: // RSB_CONDITIONAL_FREE(mtxAp // RSB_CONDITIONAL_FREE(mtxAp->all_leaf_matrices) */ rsb_err_t errval = RSB_ERR_NO_ERROR; if(rsb__is_coo_matrix(mtxAp)) { if(RSB_DO_FLAG_HAS(mtxAp->flags,(RSB_FLAG_USE_HALFWORD_INDICES))) rsb__do_switch_array_to_fullword_coo((rsb_half_idx_t*)mtxAp->bpntr,mtxAp->nnz,do_shift?mtxAp->roff:0), rsb__do_switch_array_to_fullword_coo((rsb_half_idx_t*)mtxAp->bindx,mtxAp->nnz,do_shift?mtxAp->coff:0); goto err; } errval = rsb__do_switch_compressed_array_to_fullword_coo(mtxAp->bpntr,mtxAp->Mdim,do_shift?mtxAp->roff:0,NULL); mtxAp->matrix_storage = RSB_MATRIX_STORAGE_BCOR; RSB_DO_FLAG_DEL(mtxAp->flags,(RSB_FLAG_DEFAULT_CSR_MATRIX_FLAGS)); if(RSB_SOME_ERROR(errval)) { RSB_PERR_GOTO(err,RSB_ERRM_ES); } if(RSB_DO_FLAG_HAS(mtxAp->flags,(RSB_FLAG_USE_HALFWORD_INDICES))) rsb__do_switch_array_to_fullword_coo((rsb_half_idx_t*)mtxAp->bindx,mtxAp->nnz,do_shift?mtxAp->coff:0); err: RSB_DO_FLAG_SUBST(mtxAp->flags,(RSB_FLAG_USE_HALFWORD_INDICES),(RSB_FLAG_WANT_COO_STORAGE)); // rsb__do_print_matrix_stats(mtxAp, RSB_CONST_DUMP_MATRIX_MARKET RSB_CONST_DUMP_RECURSION_BRIEF, NULL); // rsb__do_print_matrix_stats(mtxAp, RSB_CONST_DUMP_MATRIX_MARKET RSB_CONST_DUMP_RECURSION_BRIEF, NULL); RSB_DO_ERR_RETURN(errval) } rsb_err_t rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo(struct rsb_mtx_t * mtxAp, rsb_bool_t do_shift) { /** \ingroup gr_internals TODO: move somewhere else TODO: flags checks FIXME: UNTESTED // to free the unnecessary data: // RSB_CONDITIONAL_FREE(mtxAp) // RSB_CONDITIONAL_FREE(mtxAp->all_leaf_matrices) */ rsb_err_t errval = RSB_ERR_NO_ERROR; if(RSB_UNLIKELY(!mtxAp)) { RSB_ERROR(RSB_ERRM_ES); return RSB_ERR_BADARGS; } if(RSB_UNLIKELY(rsb__is_root_matrix(mtxAp))) { if(!RSB_DO_FLAG_HAS(mtxAp->flags,RSB_FLAG_ASSEMBLED_IN_COO_ARRAYS)) errval = RSB_ERR_BADARGS; else errval = rsb__do_switch_recursive_matrix_to_fullword_storage(mtxAp); if(RSB_SOME_ERROR(errval)) { RSB_PERR_GOTO(err,RSB_ERRM_ES); } } /*deleted by rsb__do_switch_recursive_matrix_to_fullword_storage*/ //RSB_DO_FLAG_ADD(mtxAp->flags,RSB_FLAG_WANT_COO_STORAGE); if(rsb__is_recursive_matrix(mtxAp->flags)) { rsb_submatrix_idx_t i,j; struct rsb_mtx_t * submatrix; RSB_SUBMATRIX_FOREACH(mtxAp,submatrix,i,j) if(submatrix) RSB_DO_ERROR_CUMULATE(errval,rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo(submatrix,do_shift)); } else errval = rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo_leaf(mtxAp,do_shift); err: RSB_DO_ERR_RETURN(errval) } static rsb_err_t rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo_parallel(struct rsb_mtx_t * mtxAp, rsb_bool_t do_shift) { /** \ingroup gr_internals */ rsb_err_t errval = RSB_ERR_NO_ERROR; const rsb_submatrix_idx_t all_leaf_matrices_n = mtxAp->all_leaf_matrices_n; rsb_submatrix_idx_t n; //rsb__do_print_matrix_stats(mtxAp, RSB_CONST_DUMP_RECURSION_BRIEF, NULL); #pragma omp parallel for schedule(static,1) reduction(|:errval) shared(mtxAp) RSB_NTC for(n=0;nall_leaf_matrices[n].mtxlp; RSB_DO_ERROR_CUMULATE(errval,rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo_leaf(submatrix,do_shift)); } //rsb__do_print_matrix_stats(mtxAp, RSB_CONST_DUMP_MATRIX_MARKET , NULL); RSB_DO_ERR_RETURN(errval) } rsb_err_t rsb__do_switch_recursive_in_place_matrix_to_in_place_coo_sorted(struct rsb_mtx_t * mtxAp, struct rsb_coo_mtx_t * coop) { /** \ingroup gr_internals Makes sense only for in place allocated. On exit, the pointer matrix is deallocated. FIXME: Here it would make sense to use a recursive merge algorithm. */ rsb_err_t errval = RSB_ERR_NO_ERROR; struct rsb_mtx_t *fsm = NULL; //rsb_flags_t flags; struct rsb_coo_mtx_t coo; int wmb = 1; /* want merge based (new: 20140727) */ RSB_BZERO_P(&coo); if(RSB_UNLIKELY(!mtxAp)) { RSB_ERROR(RSB_ERRM_E_MTXAP); return RSB_ERR_BADARGS; } if(mtxAp->all_leaf_matrices_n == 1) wmb = 0; /* merge routine will not convert a single leaf's format */ #if 0 fsm = rsb__do_get_first_submatrix(mtxAp); if(!fsm) { errval = RSB_ERR_INTERNAL_ERROR; RSB_PERR_GOTO(err,RSB_ERRM_ES); } flags = mtxAp->flags; errval = rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo(mtxAp,RSB_BOOL_TRUE); RSB_CONDITIONAL_FREE(mtxAp->all_leaf_matrices); RSB_INIT_COO_FROM_MTX(coop,mtxAp); RSB_BIND_COO_TO_MTX(coop,fsm); RSB_CONDITIONAL_FREE(mtxAp); //if((errval = rsb__util_sort_row_major_parallel(coop->VA,coop->IA,coop->JA,coop->nnz,coop->nr,coop->nc,coop->typecode,flags))!=RSB_ERR_NO_ERROR) if((errval = rsb__util_sort_row_major_bucket_based_parallel(coop->VA,coop->IA,coop->JA,coop->nnz,coop->nr,coop->nc,coop->typecode,flags))!=RSB_ERR_NO_ERROR) goto err; #else if(wmb) { errval = rsb__leaves_merge_multiple(mtxAp, NULL, NULL, NULL, 0, 1); if(RSB_SOME_ERROR(errval)) { RSB_PERR_GOTO(err, RSB_ERRM_ES); } fsm = rsb__do_get_first_submatrix(mtxAp); if(!fsm) { errval = RSB_ERR_INTERNAL_ERROR; RSB_PERR_GOTO(err, RSB_ERRM_ES); } RSB_INIT_COO_FROM_MTX(coop, mtxAp); RSB_BIND_COO_TO_MTX(coop, fsm); RSB_ASSERT(coop->VA || coop->nnz == 0); RSB_ASSERT(coop->IA || coop->nnz == 0); RSB_ASSERT(coop->JA || coop->nnz == 0); } else { fsm = rsb__do_get_first_submatrix(mtxAp); if(!fsm) { errval = RSB_ERR_INTERNAL_ERROR; RSB_PERR_GOTO(err, RSB_ERRM_ES); } RSB_INIT_CXX_FROM_MTX(&coo, mtxAp); coo.nr = coo.nc = 0; // to have rsb__allocate_coo_matrix_t allocate nnz and not more if(rsb__allocate_coo_matrix_t(&coo) != &coo) { errval = RSB_ERR_INTERNAL_ERROR; RSB_PERR_GOTO(err, RSB_ERRM_ES); } errval = rsb__do_get_rows_sparse(RSB_TRANSPOSITION_N, NULL, mtxAp, coo.VA, coo.IA, coo.JA, 0, mtxAp->nr-1, &coo.nnz, RSB_FLAG_NOFLAGS); if(RSB_SOME_ERROR(errval)) { RSB_PERR_GOTO(err, RSB_ERRM_ES); } RSB_INIT_COO_FROM_MTX(coop, mtxAp); RSB_BIND_COO_TO_MTX(coop, fsm); RSB_COO_MEMCPY_parallel(coop->VA, coop->IA, coop->JA, coo.VA, coo.IA, coo.JA, 0, 0, coo.nnz, mtxAp->el_size); rsb__destroy_coo_matrix_t(&coo); } fsm->VA = NULL; fsm->bpntr = NULL; fsm->bindx = NULL; rsb__destroy_inner(mtxAp); #endif err: RSB_DO_ERR_RETURN(errval) } rsb_err_t rsb__do_switch_recursive_in_place_matrix_to_in_place_coo_unsorted(struct rsb_mtx_t * mtxAp, struct rsb_coo_mtx_t * coop) { /** \ingroup gr_internals TODO: move somewhere else FIXME: UNTESTED,TEMPORARY, makes sense only for in place allocated this conversion gives you sorted coordinates. on exit, the pointer matrix is deallocated FIXME: error behaviour is undefined */ rsb_err_t errval = RSB_ERR_NO_ERROR; //struct rsb_coo_mtx_t coo; struct rsb_mtx_t *fsm = NULL; if(RSB_UNLIKELY(!mtxAp)) { RSB_ERROR(RSB_ERRM_ES); return RSB_ERR_BADARGS; } #if 0 RSB_INIT_CXX_FROM_MTX(&coo,mtxAp); if(rsb__allocate_coo_matrix_t(&coo)!=&coo) { errval = RSB_ERR_ENOMEM; RSB_PERR_GOTO(err,RSB_ERRM_ES); } errval = rsb__do_get_rows_sparse(RSB_TRANSPOSITION_N,NULL,mtxAp,coo.VA,coo.IA,coo.JA,0,mtxAp->nr-1,&coo.nnz,RSB_FLAG_NOFLAGS); if(RSB_SOME_ERROR(errval)) goto err; //rsb__destroy_inner(mtxAp); rsb__do_mtx_free(mtxAp); coop->VA = coo.VA; coop->IA = coo.IA; coop->JA = coo.JA; RSB_INIT_COO_FROM_MTX(coop,&coo); // mtxAp->VA = coo.VA; // mtxAp->bpntr = coo.IA; // mtxAp->bindx = coo.JA; #else fsm = rsb__do_get_first_submatrix(mtxAp); if(!fsm) { errval = RSB_ERR_INTERNAL_ERROR; RSB_PERR_GOTO(err,RSB_ERRM_ES); } errval = rsb__do_switch_recursive_in_place_matrix_to_in_place_rcoo_parallel(mtxAp,RSB_BOOL_TRUE); if(RSB_SOME_ERROR(errval)) { RSB_PERR_GOTO(err,RSB_ERRM_ES); } RSB_BIND_COO_TO_MTX(coop,fsm); RSB_INIT_COO_FROM_MTX(coop,mtxAp); fsm->VA = NULL; fsm->bpntr = NULL; fsm->bindx = NULL; rsb__destroy_inner(mtxAp); #endif err: RSB_DO_ERR_RETURN(errval) } /* @endcond */