PaStiX Handbook  6.2.1
core_ssytrfsp.c
Go to the documentation of this file.
1 /**
2  *
3  * @file core_ssytrfsp.c
4  *
5  * PaStiX kernel routines for LDL^t factorization.
6  *
7  * @copyright 2011-2021 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
8  * Univ. Bordeaux. All rights reserved.
9  *
10  * @version 6.0.3
11  * @author Mathieu Faverge
12  * @author Pierre Ramet
13  * @author Xavier Lacoste
14  * @author Gregoire Pichon
15  * @date 2019-12-19
16  * @generated from /builds/solverstack/pastix/kernels/core_zsytrfsp.c, normal z -> s, Tue Apr 12 09:38:36 2022
17  *
18  **/
19 #include "common.h"
20 #include "cblas.h"
21 #include "blend/solver.h"
22 #include "pastix_scores.h"
23 #include "kernels_trace.h"
24 
25 #include <lapacke.h>
26 
27 #ifndef DOXYGEN_SHOULD_SKIP_THIS
28 #define MAXSIZEOFBLOCKS 64
29 static float sone = 1.0;
30 static float msone = -1.0;
31 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
32 
33 /**
34  *******************************************************************************
35  *
36  * @ingroup kernel_blas_lapack_null
37  *
38  * @brief Compute the sequential static pivoting factorization of the symmetric
39  * matrix n-by-n A such that A = L * D * L^t.
40  *
41  *******************************************************************************
42  *
43  * @param[in] n
44  * The number of rows and columns of the matrix A.
45  *
46  * @param[inout] A
47  * The matrix A to factorize with LDL^t factorization. The matrix
48  * is of size lda -by- n.
49  *
50  * @param[in] lda
51  * The leading dimension of the matrix A.
52  *
53  * @param[inout] nbpivots
54  * Pointer to the number of piovting operations made during
55  * factorization. It is updated during this call
56  *
57  * @param[in] criterion
58  * Threshold use for static pivoting. If diagonal value is under this
59  * threshold, its value is replaced by the threshold and the number of
60  * pivots is incremented.
61  *
62  *******************************************************************************/
63 static inline void
64 core_ssytf2sp( pastix_int_t n,
65  float *A,
66  pastix_int_t lda,
67  pastix_int_t *nbpivots,
68  float criterion )
69 {
70  pastix_int_t k, m;
71  float *Akk = A; /* A [k ][k ] */
72  float *Amk = A+1; /* A [k+1][k ] */
73  float *Akm = A+lda; /* A [k ][k+1] */
74  float alpha;
75 
76  m = n-1;
77  for (k=0; k<n; k++, m--){
78  if ( fabsf(*Akk) < criterion ) {
79  if ( (*Akk) < 0. ) {
80  *Akk = (float)(-criterion);
81  }
82  else {
83  *Akk = (float)criterion;
84  }
85  (*nbpivots)++;
86  }
87 
88  alpha = 1.0 / (*Akk);
89 
90  /* Transpose the column before scaling */
91  cblas_scopy( m, Amk, 1, Akm, lda );
92 
93  /* Scale the diagonal to compute L((k+1):n,k) */
94  cblas_sscal(m, ( alpha ), Amk, 1 );
95 
96  alpha = -(*Akk);
97 
98  /* Move to next Akk */
99  Akk += (lda+1);
100 
101  cblas_ssyrk(CblasColMajor, CblasLower, CblasNoTrans,
102  m, 1,
103  ( alpha ), Amk, lda,
104  ( sone ), Akk, lda);
105 
106  /* Move to next Amk */
107  Amk = Akk+1;
108  Akm = Akk+lda;
109  }
110 }
111 
112 /**
113  *******************************************************************************
114  *
115  * @brief Compute the block static pivoting factorization of the symmetric
116  * matrix n-by-n A such that A = L * D * L^t.
117  *
118  *******************************************************************************
119  *
120  * @param[in] n
121  * The number of rows and columns of the matrix A.
122  *
123  * @param[inout] A
124  * The matrix A to factorize with LDL^t factorization. The matrix
125  * is of size lda -by- n.
126  *
127  * @param[in] lda
128  * The leading dimension of the matrix A.
129  *
130  * @param[inout] nbpivots
131  * Pointer to the number of piovting operations made during
132  * factorization. It is updated during this call
133  *
134  * @param[in] criterion
135  * Threshold use for static pivoting. If diagonal value is under this
136  * threshold, its value is replaced by the threshold and the nu,ber of
137  * pivots is incremented.
138  *
139  *******************************************************************************/
140 void
141 core_ssytrfsp( pastix_int_t n,
142  float *A,
143  pastix_int_t lda,
144  pastix_int_t *nbpivots,
145  float criterion )
146 {
147  pastix_int_t k, blocknbr, blocksize, matrixsize, col;
148  float *Akk, *Amk, *Akm, *Amm;
149  float alpha;
150 
151  /* diagonal supernode is divided into MAXSIZEOFBLOCK-by-MAXSIZEOFBLOCKS blocks */
152  blocknbr = pastix_iceil( n, MAXSIZEOFBLOCKS );
153 
154  for (k=0; k<blocknbr; k++) {
155 
156  blocksize = pastix_imin(MAXSIZEOFBLOCKS, n-k*MAXSIZEOFBLOCKS);
157  Akk = A+(k*MAXSIZEOFBLOCKS)*(lda+1); /* Lk, k */
158  Amk = Akk + blocksize; /* Lk+1,k */
159  Akm = Akk + blocksize * lda; /* Lk, k+1 */
160  Amm = Amk + blocksize * lda; /* Lk+1,k+1 */
161 
162  /* Factorize the diagonal block Akk*/
163  core_ssytf2sp(blocksize, Akk, lda, nbpivots, criterion);
164 
165  if ((k*MAXSIZEOFBLOCKS+blocksize) < n) {
166 
167  matrixsize = n-(k*MAXSIZEOFBLOCKS+blocksize);
168 
169  /*
170  * Solve the lower rectangle below the diagonal block
171  * L(k+1:n,k) = (L(k,k) D(k,k))^{-1} A(k+1:n,k)
172  */
173  /* 1) Compute A(k+1:n,k) = A(k+1:n,k)L(k,k)^{-T} = D(k,k)L(k+1:n,k) */
174  /* input: L(k,k) in tmp, A(k+1:n,k) in tmp1 */
175  /* output: A(k+1:n,k) in tmp1 */
176  cblas_strsm(CblasColMajor,
177  CblasRight, CblasLower,
178  CblasTrans, CblasUnit,
179  matrixsize, blocksize,
180  (sone), Akk, lda,
181  Amk, lda);
182 
183  /* Compute L(k+1:n,k) = A(k+1:n,k)D(k,k)^{-1} */
184  for(col = 0; col < blocksize; col++) {
185  /* copy L(k+1+col:n,k+col)*D(k+col,k+col) into work(:,col) */
186  cblas_scopy(matrixsize, Amk + col*lda, 1,
187  Akm + col, lda);
188 
189  /* compute L(k+1+col:n,k+col) = A(k+1+col:n,k+col)D(k+col,k+col)^{-1} */
190  alpha = 1.0 / *(Akk + col*(lda+1));
191  cblas_sscal( matrixsize, (alpha),
192  Amk + col*lda, 1 );
193  }
194 
195  /* Update A(k+1:n,k+1:n) = A(k+1:n,k+1:n) - (L(k+1:n,k)*D(k,k))*L(k+1:n,k)^T */
196  cblas_sgemm(CblasColMajor,
197  CblasNoTrans, CblasNoTrans,
198  matrixsize, matrixsize, blocksize,
199  (msone), Amk, lda,
200  Akm, lda,
201  (sone), Amm, lda);
202  }
203  }
204 }
205 
206 /**
207  *******************************************************************************
208  *
209  * @brief Computes the LDL^t factorization of the diagonal block in a panel.
210  *
211  *******************************************************************************
212  *
213  * @param[in] solvmtx
214  * Solver Matrix structure of the problem
215  *
216  * @param[in] cblk
217  * Pointer to the structure representing the panel to factorize in the
218  * cblktab array. Next column blok must be accessible through cblk[1].
219  *
220  * @param[inout] dataL
221  * The pointer to the correct representation of lower part of the data.
222  * - coeftab if the block is in full rank. Must be of size cblk.stride -by- cblk.width.
223  * - pastix_lr_block if the block is compressed.
224  *
225  *******************************************************************************
226  *
227  * @return The number of static pivoting performed during the diagonal block
228  * factorization.
229  *
230  *******************************************************************************/
231 int
232 cpucblk_ssytrfsp1d_sytrf( SolverMatrix *solvmtx,
233  SolverCblk *cblk,
234  void *dataL )
235 {
236  pastix_int_t ncols, stride;
237  pastix_int_t nbpivots = 0;
238  pastix_fixdbl_t time, flops;
239  float *L;
240  pastix_lrblock_t *lrL;
241  float criterion = solvmtx->diagthreshold;
242 
243  time = kernel_trace_start( PastixKernelSYTRF );
244 
245  ncols = cblk->lcolnum - cblk->fcolnum + 1;
246  stride = (cblk->cblktype & CBLK_LAYOUT_2D) ? ncols : cblk->stride;
247 
248  if ( cblk->cblktype & CBLK_COMPRESSED ) {
249  /* dataL is a LRblock */
250  lrL = (pastix_lrblock_t *)dataL;
251  L = lrL->u;
252  stride = ncols;
253 
254  assert( lrL->rk == -1 );
255  assert( stride == lrL->rkmax );
256  } else {
257  L = (float *)dataL;
258  }
259 
260  /*
261  * Factorize diagonal block in L D L^t
262  *
263  * - lower part holds L
264  * - diagonal holds D
265  * - uppert part holds (DL^t)
266  */
267  flops = FLOPS_SSYTRF( ncols );
268  kernel_trace_start_lvl2( PastixKernelLvl2SYTRF );
269  core_ssytrfsp( ncols, L, stride, &nbpivots, criterion );
270  kernel_trace_stop_lvl2( flops );
271 
272  kernel_trace_stop( cblk->fblokptr->inlast, PastixKernelSYTRF, ncols, 0, 0, flops, time );
273 
274  if ( nbpivots ) {
275  pastix_atomic_add_32b( &(solvmtx->nbpivots), nbpivots );
276  }
277  return nbpivots;
278 }
279 
280 /**
281  *******************************************************************************
282  *
283  * core_ssytrfsp1d_gemm - Computes the LDL^t factorization of one panel and
284  * apply all the trsm updates to this panel.
285  *
286  *******************************************************************************
287  *
288  * @param[in] cblk
289  * The pointer to the data structure that describes the panel from
290  * which we compute the contributions. Next column blok must be
291  * accessible through cblk[1].
292  *
293  * @param[in] blok
294  * The pointer to the data structure that describes the blok from which
295  * we compute the contributions.
296  *
297  * @param[in] fcblk
298  * The pointer to the data structure that describes the panel on
299  * which we compute the contributions. Next column blok must be
300  * accessible through fcblk[1].
301  *
302  * @param[inout] L
303  * The pointer to the matrix storing the coefficients of the
304  * panel. Must be of size cblk.stride -by- cblk.width
305  *
306  * @param[inout] C
307  * The pointer to the matrix storing the coefficients of the
308  * target.
309  *
310  * @param[inout] work
311  * Temporary buffer used in core_sgemdm().
312  *
313  *******************************************************************************
314  *
315  * @return
316  * The number of static pivoting during factorization of the diagonal block.
317  *
318  *******************************************************************************/
320  const SolverBlok *blok,
321  SolverCblk *fcblk,
322  const float *L,
323  float *C,
324  float *work )
325 {
326  const SolverBlok *iterblok;
327  const SolverBlok *fblok;
328  const SolverBlok *lblok;
329  const float *blokA;
330  const float *blokB;
331  const float *blokD;
332  float *blokC;
333 
334  pastix_int_t M, N, K, lda, ldb, ldc, ldd;
335 
336  /* Get the panel update dimensions */
337  K = cblk_colnbr( cblk );
338  N = blok_rownbr( blok );
339 
340  /* Get info for diagonal, and the B block */
341  blokD = L;
342  blokB = L + blok->coefind;
343  if ( cblk->cblktype & CBLK_LAYOUT_2D ) {
344  ldb = N;
345  ldd = K + 1;
346  }
347  else {
348  ldb = cblk->stride;
349  ldd = cblk->stride + 1;
350  }
351 
352  /*
353  * Add contribution to C in fcblk:
354  * Get the first facing block of the distant panel, and the last block of
355  * the current cblk
356  */
357  fblok = fcblk->fblokptr;
358  lblok = cblk[1].fblokptr;
359 
360  for (iterblok=blok; iterblok<lblok; iterblok++) {
361 
362  /* Find facing blok */
363  while (!is_block_inside_fblock( iterblok, fblok ))
364  {
365  fblok++;
366  assert( fblok < fcblk[1].fblokptr );
367  }
368 
369  /* Get the A block and its dimensions */
370  M = blok_rownbr( iterblok );
371  blokA = L + iterblok->coefind;
372  lda = (cblk->cblktype & CBLK_LAYOUT_2D) ? M : cblk->stride;
373 
374  /* Get the C block */
375  ldc = (fcblk->cblktype & CBLK_LAYOUT_2D) ? blok_rownbr(fblok) : fcblk->stride;
376 
377  blokC = C + fblok->coefind
378  + iterblok->frownum - fblok->frownum
379  + (blok->frownum - fcblk->fcolnum) * ldc;
380 
381  {
382  pastix_int_t ldw;
383  int ret;
384 
385  /* Compute ldw which should never be larger than SOLVE_COEFMAX */
386  ldw = (M+1) * K;
387 
388  pastix_cblk_lock( fcblk );
390  M, N, K,
391  -1.0, blokA, lda,
392  blokB, ldb,
393  1.0, blokC, ldc,
394  blokD, ldd,
395  work, ldw );
396  pastix_cblk_unlock( fcblk );
397  assert(ret == PASTIX_SUCCESS);
398  (void)ret;
399  }
400  }
401 }
402 
403 /**
404  *******************************************************************************
405  *
406  * @brief Compute the LDL^t factorization of one panel.
407  *
408  *******************************************************************************
409  *
410  * @param[in] solvmtx
411  * Solver Matrix structure of the problem
412  *
413  * @param[in] cblk
414  * Pointer to the structure representing the panel to factorize in the
415  * cblktab array. Next column blok must be accessible through cblk[1].
416  *
417  * @param[inout] L
418  * The pointer to the matrix storing the coefficients of the
419  * panel. Must be of size cblk.stride -by- cblk.width
420  *
421  * @param[inout] DLt
422  * The pointer to the upper matrix storing the coefficients the
423  * temporary DL^t product. Must be of size cblk.stride -by- cblk.width
424  *
425  *******************************************************************************
426  *
427  * @return The number of static pivoting during factorization of the diagonal
428  * block.
429  *
430  *******************************************************************************/
431 int
432 cpucblk_ssytrfsp1d_panel( SolverMatrix *solvmtx,
433  SolverCblk *cblk,
434  void *L,
435  void *DLt )
436 {
437  pastix_int_t nbpivots;
438  nbpivots = cpucblk_ssytrfsp1d_sytrf( solvmtx, cblk, L );
439 
440  /*
441  * We exploit the fact that (DL^t) is stored in the upper triangle part of L
442  */
445  cblk, L, L, &(solvmtx->lowrank) );
446 
447  if ( (DLt != NULL) && (cblk->cblktype & CBLK_LAYOUT_2D) ) {
448 
449  /* Copy L into the temporary buffer and multiply by D */
450  cpucblk_sscalo( PastixNoTrans, cblk, L, DLt );
451  }
452  return nbpivots;
453 }
454 
455 
456 /**
457  *******************************************************************************
458  *
459  * @brief Perform the LDL^t factorization of a given panel and apply all its
460  * updates.
461  *
462  *******************************************************************************
463  *
464  * @param[in] solvmtx
465  * Solver Matrix structure of the problem
466  *
467  * @param[in] cblk
468  * Pointer to the structure representing the panel to factorize in the
469  * cblktab array. Next column blok must be accessible through cblk[1].
470  *
471  * @param[in] DLt
472  * Temporary memory buffer to store the transpose of DLt.
473  *
474  * @param[in] work
475  * Temporary memory buffer.
476  *
477  * @param[in] lwork
478  * Temporary workspace dimension.
479  *
480  *******************************************************************************
481  *
482  * @return The number of static pivoting during factorization of the diagonal
483  * block.
484  *
485  *******************************************************************************/
486 int
487 cpucblk_ssytrfsp1d( SolverMatrix *solvmtx,
488  SolverCblk *cblk,
489  float *DLt,
490  float *work,
491  pastix_int_t lwork )
492 {
493  void *dataL = cblk_getdataL( cblk );
494  void *dataDLt = cblk_getdataU( cblk );
495  SolverCblk *fcblk;
496  SolverBlok *blok, *lblk;
497  pastix_int_t nbpivots;
498 
499  if ( !(cblk->cblktype & CBLK_LAYOUT_2D) ) {
500  DLt = NULL;
501  }
502  else {
503  if (cblk->cblktype & CBLK_COMPRESSED) {
504  cpucblk_salloc_lrws( cblk, dataDLt, DLt );
505  }
506  else {
507  assert( dataDLt == NULL );
508  dataDLt = DLt;
509  }
510  }
511 
512  /* if there are off-diagonal supernodes in the column */
513  nbpivots = cpucblk_ssytrfsp1d_panel( solvmtx, cblk, dataL, dataDLt );
514 
515  blok = cblk->fblokptr+1; /* this diagonal block */
516  lblk = cblk[1].fblokptr; /* the next diagonal block */
517 
518  for( ; blok < lblk; blok++ )
519  {
520  fcblk = solvmtx->cblktab + blok->fcblknm;
521 
522  if ( fcblk->cblktype & CBLK_FANIN ) {
523  cpucblk_salloc( PastixLCoef, fcblk );
524  }
525 
526  /* Update on L */
527  if ( DLt == NULL ) {
528  core_ssytrfsp1d_gemm( cblk, blok, fcblk,
529  dataL, fcblk->lcoeftab,
530  work );
531  }
532  else {
534  cblk, blok, fcblk,
535  dataL, dataDLt, cblk_getdataL( fcblk ),
536  work, lwork, &(solvmtx->lowrank) );
537  }
538  cpucblk_srelease_deps( PastixLCoef, solvmtx, cblk, fcblk );
539  }
540 
541  return nbpivots;
542 }
solver_blok_s::frownum
pastix_int_t frownum
Definition: solver.h:112
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
PastixTrans
@ PastixTrans
Definition: api.h:425
solver_cblk_s::fblokptr
SolverBlok * fblokptr
Definition: solver.h:134
core_ssytrfsp1d_gemm
void core_ssytrfsp1d_gemm(const SolverCblk *cblk, const SolverBlok *blok, SolverCblk *fcblk, const float *L, float *C, float *work)
Definition: core_ssytrfsp.c:319
solver_cblk_s::stride
pastix_int_t stride
Definition: solver.h:135
pastix_lrblock_s::u
void * u
Definition: pastix_lowrank.h:115
solver_cblk_s
Solver column block structure.
Definition: solver.h:127
cpucblk_ssytrfsp1d
int cpucblk_ssytrfsp1d(SolverMatrix *solvmtx, SolverCblk *cblk, float *DLt, float *work, pastix_int_t lwork)
Perform the LDL^t factorization of a given panel and apply all its updates.
Definition: core_ssytrfsp.c:487
solver_blok_s
Solver block structure.
Definition: solver.h:107
cpucblk_salloc_lrws
void cpucblk_salloc_lrws(const SolverCblk *cblk, pastix_lrblock_t *lrblok, float *ws)
Initialize lrblock structure from a workspace from all blocks of the cblk associated.
Definition: cpucblk_sinit.c:96
pastix_lrblock_s
The block low-rank structure to hold a matrix in low-rank form.
Definition: pastix_lowrank.h:112
PastixNoTrans
@ PastixNoTrans
Definition: api.h:424
PastixUpper
@ PastixUpper
Definition: api.h:444
solver_cblk_s::lcolnum
pastix_int_t lcolnum
Definition: solver.h:133
PastixNonUnit
@ PastixNonUnit
Definition: api.h:465
is_block_inside_fblock
static int is_block_inside_fblock(const SolverBlok *blok, const SolverBlok *fblok)
Check if a block is included inside another one.
Definition: solver.h:426
core_ssytf2sp
static void core_ssytf2sp(pastix_int_t n, float *A, pastix_int_t lda, pastix_int_t *nbpivots, float criterion)
Compute the sequential static pivoting factorization of the symmetric matrix n-by-n A such that A = L...
Definition: core_ssytrfsp.c:64
solver_cblk_s::lcoeftab
void * lcoeftab
Definition: solver.h:142
cpucblk_srelease_deps
void cpucblk_srelease_deps(pastix_coefside_t side, SolverMatrix *solvmtx, const SolverCblk *cblk, SolverCblk *fcbk)
Release the dependencies of the given cblk after an update.
Definition: cpucblk_smpi_coeftab.c:558
pastix_scores.h
PASTIX_SUCCESS
@ PASTIX_SUCCESS
Definition: api.h:346
PastixLCoef
@ PastixLCoef
Definition: api.h:456
core_ssytrfsp
void core_ssytrfsp(pastix_int_t n, float *A, pastix_int_t lda, pastix_int_t *nbpivots, float criterion)
Compute the block static pivoting factorization of the symmetric matrix n-by-n A such that A = L * D ...
Definition: core_ssytrfsp.c:141
cpucblk_ssytrfsp1d_sytrf
int cpucblk_ssytrfsp1d_sytrf(SolverMatrix *solvmtx, SolverCblk *cblk, void *dataL)
Computes the LDL^t factorization of the diagonal block in a panel.
Definition: core_ssytrfsp.c:232
cpucblk_salloc
void cpucblk_salloc(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_sinit.c:264
solver_blok_s::coefind
pastix_int_t coefind
Definition: solver.h:114
pastix_lrblock_s::rk
int rk
Definition: pastix_lowrank.h:113
cpucblk_strsmsp
void cpucblk_strsmsp(pastix_side_t side, pastix_uplo_t uplo, pastix_trans_t trans, pastix_diag_t diag, const SolverCblk *cblk, const void *A, void *C, const pastix_lr_t *lowrank)
Compute the updates associated to a column of off-diagonal blocks.
Definition: core_strsmsp.c:356
solver_cblk_s::cblktype
int8_t cblktype
Definition: solver.h:130
solver_blok_s::inlast
int8_t inlast
Definition: solver.h:117
solver_cblk_s::fcolnum
pastix_int_t fcolnum
Definition: solver.h:132
cpucblk_ssytrfsp1d_panel
int cpucblk_ssytrfsp1d_panel(SolverMatrix *solvmtx, SolverCblk *cblk, void *L, void *DLt)
Compute the LDL^t factorization of one panel.
Definition: core_ssytrfsp.c:432
pastix_lrblock_s::rkmax
int rkmax
Definition: pastix_lowrank.h:114
core_sgemdm
int core_sgemdm(pastix_trans_t transA, pastix_trans_t transB, int M, int N, int K, float alpha, const float *A, int LDA, const float *B, int LDB, float beta, float *C, int LDC, const float *D, int incD, float *WORK, int LWORK)
Perform one of the following matrix-matrix operations.
Definition: core_sgemdm.c:139
cpucblk_sgemmsp
pastix_fixdbl_t cpucblk_sgemmsp(pastix_coefside_t sideA, pastix_trans_t trans, const SolverCblk *cblk, const SolverBlok *blok, SolverCblk *fcblk, const void *A, const void *B, void *C, float *work, pastix_int_t lwork, const pastix_lr_t *lowrank)
Compute the updates associated to one off-diagonal block.
Definition: core_sgemmsp.c:1512
cblk_getdataU
static void * cblk_getdataU(const SolverCblk *cblk)
Get the pointer to the data associated to the upper part of the cblk.
Definition: solver.h:272
cpucblk_sscalo
void cpucblk_sscalo(pastix_trans_t trans, SolverCblk *cblk, void *dataL, void *dataLD)
Copy the L term with scaling for the two-terms algorithm.
Definition: core_sscalo.c:170
cblk_getdataL
static void * cblk_getdataL(const SolverCblk *cblk)
Get the pointer to the data associated to the lower part of the cblk.
Definition: solver.h:260
solver_blok_s::fcblknm
pastix_int_t fcblknm
Definition: solver.h:110
PastixRight
@ PastixRight
Definition: api.h:474