PaStiX Handbook  6.2.1
coeftab_z.c
Go to the documentation of this file.
1 /**
2  *
3  * @file coeftab_z.c
4  *
5  * Precision dependent sequential routines to apply operation of the full matrix.
6  *
7  * @copyright 2015-2021 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
8  * Univ. Bordeaux. All rights reserved.
9  *
10  * @version 6.2.0
11  * @author Pierre Ramet
12  * @author Xavier Lacoste
13  * @author Gregoire Pichon
14  * @author Mathieu Faverge
15  * @author Esragul Korkmaz
16  * @author Tony Delarue
17  * @date 2021-04-02
18  *
19  * @generated from /builds/solverstack/pastix/sopalin/coeftab_z.c, normal z -> z, Tue Apr 12 09:39:07 2022
20  *
21  **/
22 #include "common.h"
23 #include "blend/solver.h"
24 #include "lapacke.h"
25 #include "sopalin/coeftab_z.h"
26 #include "pastix_zcores.h"
27 
28 /**
29  *******************************************************************************
30  *
31  * @brief Dump the solver matrix coefficients into a file in human readable
32  * format.
33  *
34  * All non-zeroes coefficients are dumped in the format:
35  * i j val
36  * with one value per row.
37  *
38  *******************************************************************************
39  *
40  * @param[inout] pastix_data
41  * The pastix_data instance to access the unique directory id in which
42  * output the files.
43  *
44  * @param[in] solvmtx
45  * The solver matrix to print.
46  *
47  * @param[in] filename
48  * The filename where to store the output matrix.
49  *
50  *******************************************************************************/
51 void
52 coeftab_zdump( pastix_data_t *pastix_data,
53  const SolverMatrix *solvmtx,
54  const char *prefix )
55 {
56  SolverCblk *cblk = solvmtx->cblktab;
57  pastix_int_t itercblk;
58  char filename[256];
59  FILE *stream = NULL;
60 
61  pastix_gendirectories( pastix_data );
62 
63  /*
64  * TODO: there is a problem right here for now, because there are no
65  * distinctions between L and U coeffcients in the final file
66  */
67  for (itercblk=0; itercblk<solvmtx->cblknbr; itercblk++, cblk++)
68  {
69  if ( cblk->cblktype & (CBLK_FANIN|CBLK_RECV) ) {
70  continue;
71  }
72  if ( solvmtx->clustnum != cblk->ownerid ) {
73  continue;
74  }
75 
76  sprintf( filename, "%s_%ld.txt", prefix, (long)cblk->gcblknum );
77  stream = pastix_fopenw( pastix_data->dir_global, filename, "w" );
78  if ( stream == NULL ){
79  continue;
80  }
81 
82  cpucblk_zdump( PastixLCoef, cblk, stream );
83  if ( NULL != cblk->ucoeftab ) {
84  cpucblk_zdump( PastixUCoef, cblk, stream );
85  }
86 
87  fclose( stream );
88  }
89 }
90 
91 /**
92  *******************************************************************************
93  *
94  * @brief Compare two solver matrices in full-rank format with the same data
95  * distribution.
96  *
97  * The second solver matrix is overwritten by the difference of the two
98  * matrices. The frobenius norm of the difference of each column block is
99  * computed and the functions returns 0 if the result for all the column blocks
100  * of:
101  * || B_k - A_k || / ( || A_k || * eps )
102  *
103  * is below 10. Otherwise, an error message is printed and 1 is returned.
104  *
105  *******************************************************************************
106  *
107  * @param[in] side
108  * Define which side of the cblk must be tested.
109  * @arg PastixLCoef if lower part only
110  * @arg PastixUCoef if upper part only
111  * @arg PastixLUCoef if both sides.
112  *
113  * @param[in] solvA
114  * The solver matrix A.
115  *
116  * @param[inout] solvB
117  * The solver matrix B.
118  * On exit, B coefficient arrays are overwritten by the result of
119  * (B-A).
120  *
121  *******************************************************************************
122  *
123  * @return 0 if the test is passed, >= 0 otherwise.
124  *
125  *******************************************************************************/
126 int
128  const SolverMatrix *solvA,
129  SolverMatrix *solvB )
130 {
131  SolverCblk *cblkA = solvA->cblktab;
132  SolverCblk *cblkB = solvB->cblktab;
133  pastix_int_t cblknum;
134  int rc = 0;
135  int saved_rc = 0;
136 
137  for(cblknum=0; cblknum<solvA->cblknbr; cblknum++, cblkA++, cblkB++) {
138  rc += cpucblk_zdiff( side, cblkA, cblkB );
139  if ( rc != saved_rc ){
140  fprintf(stderr, "CBLK %ld was not correctly compressed\n", (long)cblknum);
141  saved_rc = rc;
142  }
143  }
144 
145  return rc;
146 }
147 
148 /**
149  *******************************************************************************
150  *
151  * @brief Compress all the cblks marked as valid for low-rank format.
152  *
153  * All the cblk in the top levels of the elimination tree marked as candidates
154  * for compression are compressed if there is a gain to compress them. The
155  * compression to low-rank format is parameterized by the input information
156  * stored in the lowrank structure. On exit, all the cblks marked for
157  * compression are stored through the low-rank structure, even if they are kept
158  * in their full-rank form.
159  *
160  * @remark This routine is sequential
161  *
162  *******************************************************************************
163  *
164  * @param[inout] solvmtx
165  * The solver matrix of the problem to compress.
166  *
167  *******************************************************************************
168  *
169  * @return The memory gain resulting from the compression to low-rank format in
170  * Bytes.
171  *
172  *******************************************************************************/
173 pastix_int_t
174 coeftab_zcompress( SolverMatrix *solvmtx )
175 {
176  SolverCblk *cblk = solvmtx->cblktab;
177  pastix_coefside_t side = (solvmtx->factotype == PastixFactLU) ? PastixLUCoef : PastixLCoef;
178  int ilu_lvl;
179  pastix_int_t cblknum, gain = 0;
180 
181  ilu_lvl = solvmtx->lowrank.compress_preselect ? -1 : solvmtx->lowrank.ilu_lvl;
182 
183  for(cblknum=0; cblknum<solvmtx->cblknbr; cblknum++, cblk++) {
184  if ( cblk->cblktype & CBLK_COMPRESSED ) {
185  gain += cpucblk_zcompress( solvmtx, side, ilu_lvl, cblk );
186  }
187  }
188  return gain;
189 }
190 
191 /**
192  *******************************************************************************
193  *
194  * @brief Uncompress all column block in low-rank format into full-rank format
195  *
196  *******************************************************************************
197  *
198  * @param[inout] solvmtx
199  * The solver matrix of the problem.
200  *
201  *******************************************************************************/
202 void
203 coeftab_zuncompress( SolverMatrix *solvmtx )
204 {
205  SolverCblk *cblk = solvmtx->cblktab;
206  pastix_int_t cblknum;
207  pastix_coefside_t side = (solvmtx->factotype == PastixFactLU) ? PastixLUCoef : PastixLCoef;
208 
209  for(cblknum=0; cblknum<solvmtx->cblknbr; cblknum++, cblk++) {
210  if (cblk->cblktype & CBLK_COMPRESSED) {
211  cpucblk_zuncompress( side, cblk );
212  }
213  }
214 }
215 
216 /**
217  *******************************************************************************
218  *
219  * @brief Compute the memory gain of the low-rank form over the full-rank form
220  * for the entire matrix.
221  *
222  * This function returns the memory gain in bytes for the full matrix when
223  * column blocks are stored in low-rank format compared to a full rank storage.
224  *
225  *******************************************************************************
226  *
227  * @param[in] solvmtx
228  * The solver matrix of the problem.
229  *
230  * @param[inout] dparm
231  * The double parameter array which is going to be updated.
232  *
233  *******************************************************************************/
234 void
235 coeftab_zmemory( SolverMatrix *solvmtx,
236  pastix_fixdbl_t *dparm )
237 {
238  pastix_coefside_t side = (solvmtx->factotype == PastixFactLU) ? PastixLUCoef : PastixLCoef;
239  SolverCblk *cblk = solvmtx->cblktab;
240  SolverBlok *blok;
241  pastix_int_t i, cblknum;
242  pastix_int_t gain[MEMORY_STATS_SIZE] = { 0 };
243  pastix_int_t orig[MEMORY_STATS_SIZE] = { 0 };
244  pastix_fixdbl_t memlr[MEMORY_STATS_SIZE] = { 0. };
245  pastix_fixdbl_t memfr[MEMORY_STATS_SIZE] = { 0. };
246  pastix_fixdbl_t totlr, totfr;
247 
248 #if defined(PASTIX_SUPERNODE_STATS)
249  pastix_int_t last[3] = { 0 };
250  pastix_fixdbl_t memlast[4];
251  SolverBlok *solvblok = solvmtx->bloktab;
252 
253  for(i=0; i<solvmtx->bloknbr; i++, solvblok++ ) {
254  SolverCblk *lcblk = solvmtx->cblktab + solvblok->lcblknm;
255  pastix_int_t ncols = cblk_colnbr( lcblk );
256  pastix_int_t nrows = blok_rownbr( solvblok );
257  pastix_int_t size = ncols * nrows;
258 
259  /* Skip remote data */
260  if ( cblk->ownerid != solvmtx->clustnum ) {
261  continue;
262  }
263 
264  /* Let's skip recv and fanin for now */
265  if ( lcblk->cblktype & (CBLK_RECV|CBLK_FANIN) ) {
266  continue;
267  }
268 
269  if ( !(lcblk->cblktype & CBLK_COMPRESSED) ) {
270  if ( side != PastixLCoef ) {
271  last[solvblok->inlast] += 2 * size;
272  }
273  else{
274  last[solvblok->inlast] += size;
275  }
276  }
277  else{
278  if ( side != PastixUCoef ) {
279  if ( solvblok->LRblock[0].rk >= 0 ) {
280  assert( solvblok->LRblock[0].rk <= core_get_rklimit( nrows, ncols ) );
281  assert( ((nrows+ncols) * solvblok->LRblock[0].rkmax) <= size );
282  last[solvblok->inlast] += ((nrows+ncols) * solvblok->LRblock[0].rkmax);
283  }
284  else {
285  last[solvblok->inlast] += size;
286  }
287  }
288 
289  if ( side != PastixLCoef ) {
290  if ( solvblok->LRblock[1].rk >= 0 ) {
291  assert( solvblok->LRblock[1].rk <= core_get_rklimit( nrows, ncols ) );
292  assert( ((nrows+ncols) * solvblok->LRblock[1].rkmax) <= size );
293  last[solvblok->inlast] += ((nrows+ncols) * solvblok->LRblock[1].rkmax);
294  }
295  else {
296  last[solvblok->inlast] += size;
297  }
298  }
299  }
300  }
301  for (i=0; i<3; i++) {
302  memlast[i] = last[i] * pastix_size_of( PastixComplex64 );
303  }
304  memlast[3] = memlast[0] + memlast[1] + memlast[2];
305 
306  pastix_print( solvmtx->clustnum, 0,
307  " Compression on LAST\n"
308  " ------------------------------------------------\n"
309  " A11 %8.3g %co\n"
310  " A12 %8.3g %co\n"
311  " A22 %8.3g %co\n"
312  " SUM %8.3g %co\n",
313  pastix_print_value(memlast[0]), pastix_print_unit(memlast[0]),
314  pastix_print_value(memlast[1]), pastix_print_unit(memlast[1]),
315  pastix_print_value(memlast[2]), pastix_print_unit(memlast[2]),
316  pastix_print_value(memlast[3]), pastix_print_unit(memlast[3]));
317 #endif
318 
319  for(cblknum=0; cblknum<solvmtx->cblknbr; cblknum++, cblk++) {
320  pastix_int_t colnbr = cblk_colnbr( cblk );
321 
322  /* Skip remote data */
323  if ( cblk->ownerid != solvmtx->clustnum ) {
324  continue;
325  }
326 
327  /* Let's skip recv and fanin for now */
328  if ( cblk->cblktype & (CBLK_RECV|CBLK_FANIN) ) {
329  continue;
330  }
331 
332  if ( !(cblk->cblktype & CBLK_COMPRESSED) )
333  {
334  pastix_int_t in_height = 0;
335  pastix_int_t off_height = cblk->stride;
336 
337  /* Compute the size of the original supernode diagonal block */
338  blok = cblk->fblokptr;
339  while( (blok < cblk[1].fblokptr) &&
340  ((solvmtx->cblktab + blok->fcblknm)->sndeidx == cblk->sndeidx) )
341  {
342  in_height += blok_rownbr( blok );
343  blok++;
344  }
345 
346  /* Size of the cblk outside the diagonal block */
347  off_height -= in_height;
348 
349  orig[FR_InDiag] += colnbr * in_height;
350  orig[FR_OffDiag] += colnbr * off_height;
351  }
352  else {
353  /* The gain for the diagonal block is always 0 */
354  orig[LR_DInD] += colnbr * colnbr;
355  cpucblk_zmemory( side, solvmtx, cblk, orig, gain );
356  }
357  }
358 
359  if ( side == PastixLUCoef ) {
360  orig[FR_InDiag] *= 2;
361  orig[FR_OffDiag] *= 2;
362  orig[LR_InDiag] *= 2;
363  orig[LR_OffDiag] *= 2;
364  orig[LR_InSele] *= 2;
365  }
366 
367  totlr = 0.;
368  totfr = 0.;
369 
370  for (i=0; i<MEMORY_STATS_SIZE; i++) {
371  memlr[i] = (orig[i] - gain[i]) * pastix_size_of( PastixComplex64 );
372  memfr[i] = orig[i] * pastix_size_of( PastixComplex64 );
373  totlr += memlr[i];
374  totfr += memfr[i];
375  }
376 
377  pastix_print( solvmtx->clustnum, 0,
378  " Compression:\n"
379  " ------------------------------------------------\n"
380  " Full-rank supernodes\n"
381  " Inside %8.3g %co\n"
382  " Outside %8.3g %co\n"
383  " Low-rank supernodes\n"
384  " Diag in diag %8.3g %co\n"
385  " Inside not selected %8.3g %co / %8.3g %co\n"
386  " Inside selected %8.3g %co / %8.3g %co\n"
387  " Outside %8.3g %co / %8.3g %co\n"
388  " ------------------------------------------------\n"
389  " Total %8.3g %co / %8.3g %co\n",
390  pastix_print_value(memfr[FR_InDiag] ), pastix_print_unit(memfr[FR_InDiag] ),
391  pastix_print_value(memfr[FR_OffDiag]), pastix_print_unit(memfr[FR_OffDiag]),
392 
393  pastix_print_value(memfr[LR_DInD]), pastix_print_unit(memfr[LR_DInD]),
394 
395  pastix_print_value(memlr[LR_InDiag] ), pastix_print_unit(memlr[LR_InDiag] ),
396  pastix_print_value(memfr[LR_InDiag] ), pastix_print_unit(memfr[LR_InDiag] ),
397 
398  pastix_print_value(memlr[LR_InSele] ), pastix_print_unit(memlr[LR_InSele]),
399  pastix_print_value(memfr[LR_InSele] ), pastix_print_unit(memfr[LR_InSele]),
400 
401  pastix_print_value(memlr[LR_OffDiag]), pastix_print_unit(memlr[LR_OffDiag]),
402  pastix_print_value(memfr[LR_OffDiag]), pastix_print_unit(memfr[LR_OffDiag]),
403 
404  pastix_print_value(totlr), pastix_print_unit(totlr),
405  pastix_print_value(totfr), pastix_print_unit(totfr) );
406 
407  dparm[DPARM_MEM_FR] = totfr;
408  dparm[DPARM_MEM_LR] = totlr;
409 
410  return;
411 }
412 
413 /**
414  *******************************************************************************
415  *
416  * @brief Extract the Schur complement
417  *
418  * This routine is sequential and returns the full Schur complement
419  * uncommpressed in Lapack format.
420  *
421  *******************************************************************************
422  *
423  * @param[in] solvmtx
424  * The solver matrix structure describing the problem.
425  *
426  * @param[inout] S
427  * The pointer to the allocated matrix array that will store the Schur
428  * complement.
429  *
430  * @param[in] lds
431  * The leading dimension of the S array.
432  *
433  *******************************************************************************/
434 void
435 coeftab_zgetschur( const SolverMatrix *solvmtx,
436  pastix_complex64_t *S, pastix_int_t lds )
437 {
438  SolverCblk *cblk = solvmtx->cblktab + solvmtx->cblkschur;
439  pastix_complex64_t *localS;
440  pastix_int_t itercblk, fcolnum, nbcol;
441  int upper_part = (solvmtx->factotype == PastixFactLU);
442  fcolnum = cblk->fcolnum;
443 
444  nbcol = solvmtx->nodenbr - fcolnum;
445  assert( nbcol <= lds );
446 
447  /* Initialize the array to 0 */
448  LAPACKE_zlaset_work( LAPACK_COL_MAJOR, 'A', nbcol, nbcol, 0., 0., S, lds );
449 
450  for (itercblk=solvmtx->cblkschur; itercblk<solvmtx->cblknbr; itercblk++, cblk++)
451  {
452  assert( cblk->cblktype & CBLK_IN_SCHUR );
453  assert( lds >= cblk->stride );
454 
455  localS = S + (cblk->fcolnum - fcolnum) * lds + (cblk->fcolnum - fcolnum);
456 
457  cpucblk_zgetschur( cblk, upper_part, localS, lds );
458  }
459 }
460 
461 /**
462  *******************************************************************************
463  *
464  * @brief Extract the diagonal
465  *
466  * This routine is sequential and returns the full diagonal in the vector D,
467  * such that:
468  * D[incD*i]= A(i, i)
469  *
470  *******************************************************************************
471  *
472  * @param[in] solvmtx
473  * The solver matrix structure describing the problem.
474  *
475  * @param[inout] D
476  * The pointer to the allocated vector array that will store the diagonal.
477  * D must be of size solvmtx->nodenbr * incD.
478  *
479  * @param[in] incD
480  * The increment bewteen two elements of D. incD > 0.
481  *
482  *******************************************************************************/
483 void
484 coeftab_zgetdiag( const SolverMatrix *solvmtx,
485  pastix_complex64_t *D, pastix_int_t incD )
486 {
487  SolverCblk *cblk = solvmtx->cblktab;
488  pastix_complex64_t *A;
489  pastix_int_t lda, itercblk, nbcol, i;
490 
491  for (itercblk=0; itercblk<solvmtx->cblknbr; itercblk++, cblk++)
492  {
493  nbcol = cblk_colnbr( cblk );
494  if ( cblk->cblktype & CBLK_COMPRESSED ) {
495  assert( cblk->fblokptr->LRblock[0]->rk == -1 );
496  A = cblk->fblokptr->LRblock[0]->u;
497  lda = cblk_colnbr( cblk ) + 1;
498  }
499  else {
500  A = cblk->lcoeftab;
501 
502  if ( cblk->cblktype & CBLK_LAYOUT_2D ) {
503  lda = cblk_colnbr( cblk ) + 1;
504  }
505  else {
506  lda = cblk->stride + 1;
507  }
508  }
509 
510  for (i=0; i<nbcol; i++, D += incD, A += lda ) {
511  *D = *A;
512  }
513  }
514 }
solver_cblk_s::ownerid
int ownerid
Definition: solver.h:146
FR_InDiag
@ FR_InDiag
Definition: pastix_lowrank.h:164
solver.h
blok_rownbr
static pastix_int_t blok_rownbr(const SolverBlok *blok)
Compute the number of rows of a block.
Definition: solver.h:313
cblk_colnbr
static pastix_int_t cblk_colnbr(const SolverCblk *cblk)
Compute the number of columns in a column block.
Definition: solver.h:247
core_get_rklimit
pastix_int_t(* core_get_rklimit)(pastix_int_t, pastix_int_t)
Compute the maximal rank accepted for a given matrix size. The pointer is set according to the low-ra...
Definition: kernels_trace.c:30
solver_cblk_s::fblokptr
SolverBlok * fblokptr
Definition: solver.h:134
coeftab_zgetschur
void coeftab_zgetschur(const SolverMatrix *solvmtx, pastix_complex64_t *S, pastix_int_t lds)
Extract the Schur complement.
Definition: coeftab_z.c:435
coeftab_zuncompress
void coeftab_zuncompress(SolverMatrix *solvmtx)
Uncompress all column block in low-rank format into full-rank format.
Definition: coeftab_z.c:203
solver_blok_s::lcblknm
pastix_int_t lcblknm
Definition: solver.h:109
solver_cblk_s::stride
pastix_int_t stride
Definition: solver.h:135
coeftab_zmemory
void coeftab_zmemory(SolverMatrix *solvmtx, pastix_fixdbl_t *dparm)
Compute the memory gain of the low-rank form over the full-rank form for the entire matrix.
Definition: coeftab_z.c:235
pastix_lrblock_s::u
void * u
Definition: pastix_lowrank.h:115
cpucblk_zmemory
void cpucblk_zmemory(pastix_coefside_t side, SolverMatrix *solvmtx, SolverCblk *cblk, pastix_int_t *orig, pastix_int_t *gain)
Return the memory gain of the low-rank form over the full-rank form for a single column-block.
Definition: cpucblk_zcompress.c:277
coeftab_zgetdiag
void coeftab_zgetdiag(const SolverMatrix *solvmtx, pastix_complex64_t *D, pastix_int_t incD)
Extract the diagonal.
Definition: coeftab_z.c:484
DPARM_MEM_FR
@ DPARM_MEM_FR
Definition: api.h:167
solver_cblk_s
Solver column block structure.
Definition: solver.h:127
LR_OffDiag
@ LR_OffDiag
Definition: pastix_lowrank.h:168
pastix_coefside_t
enum pastix_coefside_e pastix_coefside_t
Data blocks used in the kernel.
pastix_gendirectories
void pastix_gendirectories(pastix_data_t *pastix_data)
Generate a unique temporary directory to store output files.
Definition: api.c:69
coeftab_zdiff
int coeftab_zdiff(pastix_coefside_t side, const SolverMatrix *solvA, SolverMatrix *solvB)
Compare two solver matrices in full-rank format with the same data distribution.
Definition: coeftab_z.c:127
solver_blok_s
Solver block structure.
Definition: solver.h:107
pastix_zcores.h
DPARM_MEM_LR
@ DPARM_MEM_LR
Definition: api.h:168
FR_OffDiag
@ FR_OffDiag
Definition: pastix_lowrank.h:165
solver_cblk_s::ucoeftab
void * ucoeftab
Definition: solver.h:143
coeftab_zcompress
pastix_int_t coeftab_zcompress(SolverMatrix *solvmtx)
Compress all the cblks marked as valid for low-rank format.
Definition: coeftab_z.c:174
solver_cblk_s::sndeidx
pastix_int_t sndeidx
Definition: solver.h:139
cpucblk_zdump
void cpucblk_zdump(pastix_coefside_t side, const SolverCblk *cblk, FILE *stream)
Dump a single column block into a FILE in a human readale format.
Definition: coeftab_zinit.c:51
cpucblk_zgetschur
void cpucblk_zgetschur(const SolverCblk *cblk, int upper_part, pastix_complex64_t *S, pastix_int_t lds)
Extract a cblk panel of the Schur complement to a dense lapack form.
Definition: cpucblk_zschur.c:178
solver_cblk_s::lcoeftab
void * lcoeftab
Definition: solver.h:142
PastixUCoef
@ PastixUCoef
Definition: api.h:457
pastix_fopenw
FILE * pastix_fopenw(const char *dirname, const char *filename, const char *mode)
Open a file in the unique directory of the pastix instance.
Definition: api.c:232
LR_InSele
@ LR_InSele
Definition: pastix_lowrank.h:167
PastixLCoef
@ PastixLCoef
Definition: api.h:456
cpucblk_zdiff
int cpucblk_zdiff(pastix_coefside_t side, const SolverCblk *cblkA, SolverCblk *cblkB)
Compare two column blocks in full-rank format.
Definition: cpucblk_zdiff.c:63
solver_cblk_s::gcblknum
pastix_int_t gcblknum
Definition: solver.h:140
pastix_lrblock_s::rk
int rk
Definition: pastix_lowrank.h:113
LR_InDiag
@ LR_InDiag
Definition: pastix_lowrank.h:166
solver_cblk_s::cblktype
int8_t cblktype
Definition: solver.h:130
PastixLUCoef
@ PastixLUCoef
Definition: api.h:458
solver_blok_s::inlast
int8_t inlast
Definition: solver.h:117
coeftab_z.h
solver_cblk_s::fcolnum
pastix_int_t fcolnum
Definition: solver.h:132
PastixFactLU
@ PastixFactLU
Definition: api.h:304
LR_DInD
@ LR_DInD
Definition: pastix_lowrank.h:169
solver_blok_s::LRblock
pastix_lrblock_t * LRblock[2]
Definition: solver.h:121
cpucblk_zcompress
pastix_int_t cpucblk_zcompress(const SolverMatrix *solvmtx, pastix_coefside_t side, int max_ilulvl, SolverCblk *cblk)
Compress a single column block from full-rank to low-rank format.
Definition: cpucblk_zcompress.c:110
pastix_lrblock_s::rkmax
int rkmax
Definition: pastix_lowrank.h:114
cpucblk_zuncompress
void cpucblk_zuncompress(pastix_coefside_t side, SolverCblk *cblk)
Uncompress a single column block from low-rank format to full-rank format.
Definition: cpucblk_zcompress.c:197
coeftab_zdump
void coeftab_zdump(pastix_data_t *pastix_data, const SolverMatrix *solvmtx, const char *prefix)
Dump the solver matrix coefficients into a file in human readable format.
Definition: coeftab_z.c:52
solver_blok_s::fcblknm
pastix_int_t fcblknm
Definition: solver.h:110