60 double dof = (double)(symbmtx->
dof);
71 for(k = cblk[0].bloknum+1; k < cblk[1].
bloknum; k++)
81 nbops = fptr->
diag( N );
83 nbops += fptr->
trsm( M, N );
84 nbops += fptr->
update( N, M );
128 double dof = (double)(symbmtx->
dof);
139 for(l = cblk[0].bloknum+1; l < cblk[1].
bloknum; l++)
147 nbops = fptr->
diag( N );
149 nbops += fptr->
trsm( M, N );
156 for(l = cblk[0].bloknum+1; l < cblk[1].
bloknum; l++)
210 double dof = (double)(symbmtx->
dof);
221 for(l = cblk[0].bloknum+1; l < cblk[1].
bloknum; l++)
229 nbops = fptr->
diag( N );
231 nbops += fptr->
trsm( M, N );
240 for(l = cblk[0].bloknum+1; l < cblk[1].
bloknum; l++, blokcost++)
296 return fval(fptr, symbmtx, a);
340 for(itercblk=0; itercblk<cblknbr; itercblk++, cblk++)
349 nnz += ( colnbr * (colnbr+1) ) / 2 - colnbr;
352 for( ; iterblok < lbloknum; iterblok++, blok++)
354 pastix_int_t rownbr = (blok->lrownum - blok->frownum + 1) * dof;
356 nnz += rownbr * colnbr;
361 assert( symbptr->
baseval == 0 );
363 for(itercblk=0; itercblk<cblknbr; itercblk++, cblk++)
371 nnz += ( colnbr * (colnbr+1) ) / 2 - colnbr;
374 for( ; iterblok < lbloknum; iterblok++, blok++)
378 nnz += rownbr * colnbr;
428 int iscomplex = ((flttype == PastixComplex32) || (flttype == PastixComplex64)) ? 1 : 0;
431 if ( thflops != NULL ) {
438 if ( rlflops != NULL ) {
487 double *cblkptr, *blokptr;
489 int iscomplex = ((flttype == PastixComplex32) || (flttype == PastixComplex64)) ? 1 : 0;
496 for(i=0; i<symbmtx->
cblknbr; i++, cblkptr++) {
497 *cblkptr =
sum2dext( f, symbmtx, i, blokptr );
503 assert( ( cblkptr - cblkcost ) == symbmtx->
cblknbr );
504 assert( ( blokptr - blokcost ) == symbmtx->
bloknbr );
BEGIN_C_DECLS typedef int pastix_int_t
spm_coeftype_t pastix_coeftype_t
Arithmetic types.
enum pastix_factotype_e pastix_factotype_t
Factorization algorithms available for IPARM_FACTORIZATION parameter.
size_t pastixSymbolGetNNZ(const symbol_matrix_t *symbptr)
Computes the number of non-zero elements in L.
void pastixSymbolGetTimes(const symbol_matrix_t *symbmtx, pastix_coeftype_t flttype, pastix_factotype_t factotype, double *cblkcost, double *blokcost)
Computes the cost of structure for the costMatrixBuild() function.
void pastixSymbolGetFlops(const symbol_matrix_t *symbmtx, pastix_coeftype_t flttype, pastix_factotype_t factotype, double *thflops, double *rlflops)
Computes the number of theoretical and real flops.
Symbol column block structure.
double(* update)(pastix_int_t, pastix_int_t)
double(* trsm)(pastix_int_t, pastix_int_t)
double(* diag)(pastix_int_t)
double(* blkupdate)(pastix_int_t, pastix_int_t, pastix_int_t)
static double sum2dext(const symbol_function_t *fptr, const symbol_matrix_t *symbmtx, pastix_int_t cblknum, double *blokcost)
Template function to compute cost on block based approach which keeps the cost per block.
symbol_function_t flopstable[2][5]
array of pointer to the flops functions per factorization and arithmetic
static double recursive_sum(pastix_int_t a, pastix_int_t b, double(*fval)(const symbol_function_t *, const symbol_matrix_t *, pastix_int_t), const symbol_function_t *fptr, const symbol_matrix_t *symbmtx)
Recursive function to compute the cost of the full symbolic structure with either sum1d(),...
symbol_function_t perfstable[2][5]
array of pointer to the performance functions per factorization and arithmetic
static double sum2d(const symbol_function_t *fptr, const symbol_matrix_t *symbmtx, pastix_int_t cblknum)
Template function to compute cost on block based approach.
static double sum1d(const symbol_function_t *fptr, const symbol_matrix_t *symbmtx, pastix_int_t cblknum)
Template function to compute cost on a column-block based approach with a single update per column bl...
Cost functions to compute statistics on the symbolic structure.