29 #define BCSC_COMM_NBR 6
55 bcsc_comm = bcsc->bcsc_comm;
57 bcsc_comm->
flttype = bcsc->flttype;
58 bcsc_comm->
clustnbr = solvmtx->clustnbr;
59 bcsc_comm->
clustnum = solvmtx->clustnum;
60 bcsc_comm->
comm = solvmtx->solv_comm;
85 for ( c = 0; c < clustnbr; c++ ) {
115 #if defined(PASTIX_WITH_MPI)
149 pastix_int_t idxcnt_A, idxcnt_At, idxcnt_AAt, valcnt_A, valcnt_At, valcnt_AAt, c;
152 for ( c = 0; c < clustnbr; c++ ) {
154 if ( c == clustnum ) {
165 max_idx = pastix_imax( max_idx, idxcnt_A);
166 max_idx = pastix_imax( max_idx, idxcnt_At);
167 max_idx = pastix_imax( max_idx, idxcnt_AAt);
168 max_val = pastix_imax( max_val, valcnt_A);
169 max_val = pastix_imax( max_val, valcnt_At);
170 max_val = pastix_imax( max_val, valcnt_AAt);
172 idxsum_A += idxcnt_A;
173 valsum_A += valcnt_A;
174 idxsum_At += idxcnt_At;
175 valsum_At += valcnt_At;
176 idxsum_AAt += idxcnt_AAt;
177 valsum_AAt += valcnt_AAt;
180 data_local = bcsc_comm->
data_comm + clustnum;
188 assert( max_idx <= 2 * max_val );
232 if ( mode == PastixTagMemRecvIdx ) {
248 if ( mode == PastixTagMemRecvValAAt ) {
249 for ( c = 0; c < clustnbr; c ++ ) {
251 if ( c == clustnum ) {
261 if ( mode == PastixTagMemSend ) {
262 for ( c = 0; c < clustnbr; c ++ ) {
265 if ( c == clustnum ) {
336 if ( mode == PastixTagMemSendIdx ) {
337 for ( c = 0; c < clustnbr; c ++ ) {
339 if ( c == clustnum ) {
354 if ( mode == PastixTagMemSendValA ) {
355 for ( c = 0; c < clustnbr; c ++ ) {
357 if ( c == clustnum ) {
366 if ( mode == PastixTagMemSendValAt ) {
367 for ( c = 0; c < clustnbr; c ++ ) {
369 if ( c == clustnum ) {
378 if ( mode == PastixTagMemSendValAAt ) {
379 for ( c = 0; c < clustnbr; c ++ ) {
381 if ( c == clustnum ) {
390 if ( mode == PastixTagMemRecvIdxA ) {
397 if ( mode == PastixTagMemRecvIdxAt ) {
404 if ( mode == PastixTagMemRecvAAt ) {
440 MPI_Status statuses[(clustnbr-1)*BCSC_COMM_NBR];
441 MPI_Request requests[(clustnbr-1)*BCSC_COMM_NBR];
446 c_send = (clustnum+1) % clustnbr;
447 c_recv = (clustnum-1+clustnbr) % clustnbr;
448 for ( k = 0; k < clustnbr-1; k++ ) {
449 data_send = data_comm + c_send;
450 data_recv = data_comm + c_recv;
452 if ( c_send == clustnum ) {
458 recvs = &( data_recv->
recvA );
459 MPI_Irecv( recvs, 2, PASTIX_MPI_INT, c_recv,
460 PastixTagCountA, bcsc_comm->
comm, &requests[counter_req++] );
462 MPI_Isend( sends, 2, PASTIX_MPI_INT, c_send,
463 PastixTagCountA, bcsc_comm->
comm, &requests[counter_req++] );
467 recvs = &( data_recv->
recvAt );
468 MPI_Irecv( recvs, 2, PASTIX_MPI_INT, c_recv,
469 PastixTagCountAt, bcsc_comm->
comm, &requests[counter_req++] );
471 MPI_Isend( sends, 2, PASTIX_MPI_INT, c_send,
472 PastixTagCountAt, bcsc_comm->
comm, &requests[counter_req++] );
477 MPI_Irecv( recvs, 2, PASTIX_MPI_INT, c_recv,
478 PastixTagCountAAt, bcsc_comm->
comm, &requests[counter_req++] );
480 MPI_Isend( sends, 2, PASTIX_MPI_INT, c_send,
481 PastixTagCountAAt, bcsc_comm->
comm, &requests[counter_req++] );
483 c_send = (c_send+1) % clustnbr;
484 c_recv = (c_recv-1+clustnbr) % clustnbr;
487 MPI_Waitall( counter_req, requests, statuses );
489 bcsc_compute_max( bcsc_comm );
523 const pastix_bcsc_t *bcsc )
531 memset( col2cblk, 0xff, bcsc->gN *
sizeof(
pastix_int_t) );
536 for ( cblknum = 0; cblknum < cblknbr; cblknum++, cblk++ ) {
537 if ( cblk->
cblktype & (CBLK_FANIN|CBLK_RECV) ) {
544 for ( j = cblk->
fcolnum; j <= cblk->lcolnum; j++ ) {
545 col2cblk[j] = cblknum;
552 #if defined(PASTIX_WITH_MPI)
582 const pastix_bcsc_t *bcsc )
594 memset( col2cblk, 0xff, bcsc->gN *
sizeof(
pastix_int_t) );
596 for( c = 0; c < clustnbr; c++ ) {
597 if ( c == clustnum ) {
605 MPI_Bcast( &n, 1, PASTIX_MPI_INT, c, solvmtx->solv_comm );
616 if ( pastix_unlikely( tmp == NULL ) ) {
617 pastix_print_error(
"Error reallocating col2cblk_bcast\n" );
619 col2cblk_bcast = tmp;
625 for ( cblknum = 0; cblknum < cblknbr; cblknum++, cblk++ ) {
626 if ( cblk->
cblktype & (CBLK_FANIN|CBLK_RECV) ) {
629 assert( col2cblk_bcast != NULL );
632 col2cblk_bcast[k] = cblk->
fcolnum;
633 col2cblk_bcast[k+1] = cblk->
lcolnum;
639 for ( j = cblk->
fcolnum; j <= cblk->lcolnum; j++ ) {
641 col2cblk[j] = cblknum;
644 assert( colcount == bcsc->n );
648 MPI_Bcast( col2cblk_bcast, n, PASTIX_MPI_INT, c, solvmtx->solv_comm );
653 MPI_Bcast( &n, 1, PASTIX_MPI_INT, c, solvmtx->solv_comm );
664 if ( pastix_unlikely( tmp == NULL ) ) {
665 pastix_print_error(
"Error reallocating col2cblk_bcast\n" );
667 col2cblk_bcast = tmp;
671 MPI_Bcast( col2cblk_bcast, n, PASTIX_MPI_INT, c, solvmtx->solv_comm );
676 for ( k = 0; k < n; k += 2 ) {
677 fcolnum = col2cblk_bcast[k];
678 lcolnum = col2cblk_bcast[k+1];
679 for ( j = fcolnum; j <= lcolnum; j++ ) {
680 col2cblk[j] = - c - 1;
686 free( col2cblk_bcast );
722 const pastix_bcsc_t *bcsc,
723 const spmatrix_t *spm )
728 #if defined(PASTIX_WITH_MPI)
729 if ( spm->loc2glob != NULL ) {
730 col2cblk = bcsc_init_col2cblk_dst( solvmtx, bcsc );
779 for ( jg = 0; jg < spm->gN; jg++ ) {
781 dofidx = (dof > 0) ? jgp * dof : dofs[jg];
782 ptr = dofshift + dofidx;
783 dofj = (dof > 0) ? dof : dofs[jg+1] - dofs[jg];
784 for ( idof = 0; idof < dofj; idof++, ptr++ ) {
825 int sym = (spm->mtxtype == SpmSymmetric) || (spm->mtxtype == SpmHermitian);
828 assert( spm->loc2glob == NULL );
831 for ( j = 0; j < spm->n; j++, colptr++ ) {
834 frow = colptr[0] - baseval;
835 lrow = colptr[1] - baseval;
836 assert( (lrow - frow) >= 0 );
838 globcol[jgp] += (lrow - frow) * dof;
849 for ( k = frow; k < lrow; k++ ) {
850 ig = rowptr[k] - baseval;
896 int sym = (spm->mtxtype == SpmSymmetric) || (spm->mtxtype == SpmHermitian);
898 assert( spm->dof <= 0 );
899 assert( spm->loc2glob == NULL );
902 for ( j=0; j<spm->n; j++, colptr++ ) {
904 dofj = dofs[jg+1] - dofs[jg];
906 frow = colptr[0] - baseval;
907 lrow = colptr[1] - baseval;
908 assert( (lrow - frow) >= 0 );
910 for ( k=frow; k<lrow; k++ ) {
911 ig = rowptr[k] - baseval;
912 dofi = dofs[ig+1] - dofs[ig];
914 globcol[jgp] += dofi;
917 if ( sym && (ig != jg) ) {
919 globcol[igp] += dofj;
927 #if defined(PASTIX_WITH_MPI)
987 bcsc_init_global_coltab_dst_cdof(
const spmatrix_t *spm,
1002 int sym = (spm->mtxtype == SpmSymmetric) || (spm->mtxtype == SpmHermitian);
1008 for ( jl = 0; jl < spm->n; jl++, colptr++, loc2glob++ ) {
1009 jg = *loc2glob - baseval;
1012 frow = colptr[0] - baseval;
1013 lrow = colptr[1] - baseval;
1014 assert( (lrow - frow) >= 0 );
1016 ownerj = col2cblk[jgp * dof];
1020 ownerj = - ownerj - 1;
1021 data_comm = bcsc_comm->
data_comm + ownerj;
1022 data_sendA = &( data_comm->
sendA );
1025 for ( il = frow; il < lrow; il++ ) {
1026 ig = rowptr[il] - baseval;
1032 if ( sym && ( ig == jg ) ) {
1039 owneri = col2cblk[igp* dof];
1043 owneri = - owneri - 1;
1044 data_comm = bcsc_comm->
data_comm + owneri;
1050 if ( owneri == ownerj ) {
1051 data_sendAAt = &( data_comm->
sendAAt );
1061 data_sendAt = &( data_comm->
sendAt );
1083 globcol[igp] += dof;
1091 globcol[jgp] += dof * ( lrow - frow );
1094 for ( il = frow; il < lrow; il++ ) {
1095 ig = rowptr[il] - baseval;
1101 if ( sym && ( ig == jg ) ) {
1106 owneri = col2cblk[igp* dof];
1110 owneri = - owneri - 1;
1111 data_comm = bcsc_comm->
data_comm + owneri;
1117 data_sendAt = &( data_comm->
sendAt );
1128 globcol[igp] += dof;
1171 bcsc_init_global_coltab_dst_vdof( __attribute__((unused))
const spmatrix_t *spm,
1269 MPI_Status statuses[(clustnbr-1)*BCSC_COMM_NBR];
1270 MPI_Request requests[(clustnbr-1)*BCSC_COMM_NBR];
1276 bcsc_allocate_buf( bcsc_comm, PastixTagMemRecvIdx );
1278 for ( k = 0; k < clustnbr; k++ ) {
1279 if ( k == clustnum ) {
1285 idx_cnt_A[ k ] = cntA;
1287 idx_cnt_At[ k ] = cntAt;
1289 idx_cnt_AAt[ k ] = cntAAt;
1293 c_send = (clustnum+1) % clustnbr;
1294 c_recv = (clustnum-1+clustnbr) % clustnbr;
1295 for ( k = 0; k < clustnbr-1; k++ ) {
1296 data_send = data_comm + c_send;
1297 data_recv = data_comm + c_recv;
1298 if ( c_send == clustnum ) {
1303 recv = &( data_recv->recvA );
1304 if ( recv->
idxcnt != 0 ) {
1305 MPI_Irecv( sendA_local->
idxbuf + idx_cnt_A[c_recv], recv->
idxcnt,
1306 PASTIX_MPI_INT, c_recv, PastixTagIndexesA, bcsc_comm->
comm,
1307 &requests[counter_req++] );
1309 recv = &( data_recv->recvAt );
1310 if ( recv->
idxcnt != 0 ) {
1311 MPI_Irecv( sendAt_local->
idxbuf + idx_cnt_At[c_recv], recv->
idxcnt,
1312 PASTIX_MPI_INT, c_recv, PastixTagIndexesAt, bcsc_comm->
comm,
1313 &requests[counter_req++] );
1315 recv = &( data_recv->recvAAt.size );
1316 if ( recv->
idxcnt != 0 ) {
1317 MPI_Irecv( sendAAt_local->
idxbuf + idx_cnt_AAt[c_recv], recv->
idxcnt,
1318 PASTIX_MPI_INT, c_recv, PastixTagIndexesAAt, bcsc_comm->
comm,
1319 &requests[counter_req++] );
1323 send = &( data_send->sendA );
1326 PastixTagIndexesA, bcsc_comm->
comm, &requests[counter_req++] );
1328 send = &( data_send->sendAt );
1331 PastixTagIndexesAt, bcsc_comm->
comm, &requests[counter_req++] );
1333 send = &( data_send->sendAAt );
1336 PastixTagIndexesAAt, bcsc_comm->
comm, &requests[counter_req++] );
1338 c_send = (c_send+1) % clustnbr;
1339 c_recv = (c_recv-1+clustnbr) % clustnbr;
1342 MPI_Waitall( counter_req, requests, statuses );
1370 bcsc_update_globcol(
const spmatrix_t *spm,
1391 indexes_A = sendA_local->
idxbuf;
1392 indexes_At = sendAt_local->
idxbuf;
1393 indexes_AAt = sendAAt_local->
idxbuf;
1396 for ( k = 0; k < data_local->
recvA.
idxcnt; k += 2, indexes_A += 2 ) {
1399 ig = ord->
peritab[igp] - baseval;
1402 globcol[jgp] += ( dof < 0 ) ? dofs[ ig+1 ] - dofs[ig] : dof;
1406 if ( spm->mtxtype != SpmGeneral ) {
1407 for ( k = 0; k < data_local->
recvAt.
idxcnt; k += 2, indexes_At += 2 ) {
1408 igp = indexes_At[0];
1409 jgp = indexes_At[1];
1410 jg = ord->
peritab[jgp] - baseval;
1413 globcol[igp] += ( dof < 0 ) ? dofs[ jg+1 ] - dofs[jg] : dof;
1419 igp = indexes_AAt[0];
1420 jgp = indexes_AAt[1];
1421 ig = ord->
peritab[igp] - baseval;
1422 jg = ord->
peritab[jgp] - baseval;
1425 globcol[jgp] += ( dof < 0 ) ? dofs[ ig+1 ] - dofs[ig] : dof;
1427 if ( spm->mtxtype != SpmGeneral ) {
1429 globcol[igp] += ( dof < 0 ) ? dofs[ jg+1 ] - dofs[jg] : dof;
1492 memset( globcol, 0, (spm->gN+1) *
sizeof(
pastix_int_t) );
1494 if ( bcsc_comm == NULL ) {
1495 if ( spm->dof > 0 ) {
1502 #if defined(PASTIX_WITH_MPI)
1504 if ( spm->dof > 0 ) {
1505 bcsc_init_global_coltab_dst_cdof( spm, ord, col2cblk, globcol, bcsc_comm );
1508 bcsc_init_global_coltab_dst_vdof( spm, ord, col2cblk, globcol, bcsc_comm );
1512 bcsc_exchange_amount_of_data( bcsc_comm );
1515 switch( spm->flttype ) {
1517 bcsc_sstore_data( spm, ord, col2cblk, bcsc_comm );
1520 bcsc_dstore_data( spm, ord, col2cblk, bcsc_comm );
1523 bcsc_cstore_data( spm, ord, col2cblk, bcsc_comm );
1526 bcsc_zstore_data( spm, ord, col2cblk, bcsc_comm );
1530 fprintf(stderr,
"bcsc_init: Error unknown floating type for input spm\n");
1534 bcsc_exchange_indexes( bcsc_comm );
1535 bcsc_update_globcol( spm, ord, globcol, bcsc_comm );
1537 #if !defined(NDEBUG)
1539 if ( spm->dof > 0 ) {
1544 for( ig=0; ig<spm->gN; ig++ ) {
1546 ipe = ( spm->dof > 0 ) ? ip * spm->dof : spm->dofs[ ig ] - spm->baseval;
1547 if ( col2cblk[ipe] < 0 ) {
1551 dofi = ( spm->dof > 0 ) ? spm->dof: spm->dofs[ig+1] - spm->dofs[ig];
1552 nnzl += globcol[ip] * dofi;
1554 MPI_Allreduce( &nnzl, &nnzg, 1, PASTIX_MPI_INT, MPI_SUM, spm->comm );
1556 if ( spm->mtxtype != SpmGeneral ) {
1561 nnz = spm->gnnzexp * 2;
1562 assert( nnzg <= nnz );
1563 nnz = nnz - (spm->gN * spm->dof * spm->dof);
1564 assert( nnzg >= nnz );
1568 assert( nnzg == nnz );
1619 pastix_bcsc_t *bcsc )
1625 pastix_int_t cblknum, bcscnum, iter, idxcol, nodeidx, colsize;
1628 MALLOC_INTERN( bcsc->cscftab, bcsc->cscfnbr,
bcsc_cblk_t );
1639 blockcol = bcsc->cscftab;
1640 for ( cblknum = 0; cblknum < solvmtx->
cblknbr; cblknum++, cblk++ ) {
1641 if ( cblk->
cblktype & (CBLK_FANIN|CBLK_RECV) ) {
1647 assert( cblk->
bcscnum == bcscnum );
1650 blockcol->
coltab[0] = idxcol;
1651 for ( iter = 0; iter < blockcol->
colnbr; iter++ ) {
1652 nodeidx = dofshift[ cblk->
fcolnum + iter ];
1653 colsize = globcol[nodeidx];
1657 blockcol->
coltab[iter+1] = blockcol->
coltab[iter] + colsize;
1664 assert( (blockcol - bcsc->cscftab) == bcsc->cscfnbr );
1665 assert( bcscnum == bcsc->cscfnbr );
1667 memFree_null( globcol );
1668 memFree_null( dofshift );
1672 MALLOC_INTERN( bcsc->Lvalues, idxcol * pastix_size_of( bcsc->flttype ),
char );
1675 bcsc->rowtab = NULL;
1676 bcsc->Lvalues = NULL;
1678 bcsc->Uvalues = NULL;
1706 blockcol = bcsc->cscftab;
1707 for ( index=0; index<bcsc->cscfnbr; index++, blockcol++ )
1709 for ( iter=0; iter <= blockcol->
colnbr; iter++ )
1711 idxcoltmp = blockcol->
coltab[iter];
1712 blockcol->
coltab[iter] = idxcol;
1741 pastix_bcsc_t *bcsc )
1745 bcsc->mtxtype = spm->mtxtype;
1746 bcsc->flttype = spm->flttype;
1747 bcsc->gN = spm->gNexp;
1755 bcsc->col2cblk = col2cblk;
1761 bcsc->bcsc_comm = NULL;
1762 if ( spm->loc2glob != NULL ) {
1783 if ( bcsc->col2cblk != NULL ) {
1784 memFree_null( bcsc->col2cblk );
1787 if ( bcsc->bcsc_comm != NULL ) {
1789 memFree_null( bcsc->bcsc_comm );
1829 pastix_bcsc_t *bcsc )
1841 switch( spm->flttype ) {
1843 bcsc_sinit( spm, ord, solvmtx, initAt, bcsc, valuesize );
1846 bcsc_dinit( spm, ord, solvmtx, initAt, bcsc, valuesize );
1849 bcsc_cinit( spm, ord, solvmtx, initAt, bcsc, valuesize );
1852 bcsc_zinit( spm, ord, solvmtx, initAt, bcsc, valuesize );
1856 fprintf(stderr,
"bcsc_init: Error unknown floating type for input spm\n");
1903 pastix_bcsc_t *bcsc )
1908 assert( ord->
vertnbr == spm->gN );
1911 bcsc_init( spm, ord, solvmtx, initAt, bcsc );
1934 if ( bcsc->cscftab == NULL ) {
1938 for ( i=0, cblk=bcsc->cscftab; i < bcsc->cscfnbr; i++, cblk++ ) {
1939 memFree_null( cblk->
coltab );
1942 memFree_null( bcsc->cscftab );
1943 memFree_null( bcsc->rowtab );
1945 if ( (bcsc->Uvalues != NULL) &&
1946 (bcsc->Uvalues != bcsc->Lvalues) ) {
1947 memFree_null( bcsc->Uvalues );
1950 memFree_null( bcsc->Lvalues );
static void bcsc_init_global_coltab_shm_vdof(const spmatrix_t *spm, const pastix_order_t *ord, pastix_int_t *globcol)
Initializes the coltab of a block csc matrix. The coltab corresponds to the number of rows (expended)...
static pastix_int_t * bcsc_init_global_coltab(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, const pastix_int_t *col2cblk, bcsc_handle_comm_t *bcsc_comm)
Initializes the coltab of a block csc matrix. The coltab corresponds to the number of rows (expended)...
static void bcsc_init(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, pastix_int_t initAt, pastix_bcsc_t *bcsc)
Initializes a block csc.
static void bcsc_init_global_coltab_shm_cdof(const spmatrix_t *spm, const pastix_order_t *ord, pastix_int_t *globcol)
Initializes the coltab of a block csc matrix. The coltab corresponds to the number of rows (expended)...
static pastix_int_t * bcsc_init_dofshift(const spmatrix_t *spm, const pastix_order_t *ord)
Initializes the dofshit array of size gNexp which gives dofshift[index_permuted] = index....
BEGIN_C_DECLS typedef int pastix_int_t
void bcsc_restore_coltab(pastix_bcsc_t *bcsc)
Restores the coltab array when it has been modified to initialize the row and values arrays.
void bcsc_init_struct(const spmatrix_t *spm, const SolverMatrix *solvmtx, pastix_bcsc_t *bcsc)
Initializes a block csc.
pastix_int_t bcsc_init_coltab(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, pastix_bcsc_t *bcsc)
Initializes the coltab of a block csc matrix. The coltab corresponds to the number of rows (expended)...
void bcsc_sinit(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, int initAt, pastix_bcsc_t *bcsc, pastix_int_t valuesize)
Initializes a centralize float block csc.
pastix_int_t * bcsc_init_col2cblk(const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, const spmatrix_t *spm)
Creates the array which represents the repartition of each column in the block structure....
void bcsc_handle_comm_init(const SolverMatrix *solvmtx, pastix_bcsc_t *bcsc)
Initializes the bcsc_handle_comm_t structure.
pastix_int_t * bcsc_init_col2cblk_shm(const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc)
Creates the array which represents the repartition of each column in the block structure....
void bcsc_zinit(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, int initAt, pastix_bcsc_t *bcsc, pastix_int_t valuesize)
Initializes a centralize pastix_complex64_t block csc.
void bcsc_cinit(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, int initAt, pastix_bcsc_t *bcsc, pastix_int_t valuesize)
Initializes a centralize pastix_complex32_t block csc.
void bcsc_exit_struct(pastix_bcsc_t *bcsc)
Cleanup the bcsc struct. (symmetric of bcsc_init_struct)
void bcsc_dinit(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, int initAt, pastix_bcsc_t *bcsc, pastix_int_t valuesize)
Initializes a centralize double block csc.
void bcsc_handle_comm_exit(bcsc_handle_comm_t *bcsc_comm)
Frees the bcsc_handle_comm pointers.
bcsc_proc_comm_t data_comm[1]
bcsc_data_amount_t recvAt
pastix_coeftype_t flttype
enum bcsc_tag_ bcsc_tag_e
Tags used in MPI communications.
double bcscInit(const spmatrix_t *spm, const pastix_order_t *ord, const SolverMatrix *solvmtx, pastix_int_t initAt, pastix_bcsc_t *bcsc)
Initializes the block csc matrix.
struct bcsc_handle_comm_s bcsc_handle_comm_t
Structure to manage communications with distributed spm.
struct bcsc_proc_comm_s bcsc_proc_comm_t
Informations of the data exchanged with other processors.
void bcscExit(pastix_bcsc_t *bcsc)
Frees the block csc structure but do not free the bcsc pointer.
Compressed colptr format for the bcsc.
Information about the amount of data.
Information about the sending data.
Structure to manage communications with distributed spm.
Informations of the data exchanged with other processors.
static pastix_int_t cblk_colnbr(const SolverCblk *cblk)
Compute the number of columns in a column block.
SolverCblk *restrict cblktab
Solver column block structure.
Solver column block structure.