PaStiX Handbook  6.3.2
starpu_chetrf.c
Go to the documentation of this file.
1 /**
2  *
3  * @file starpu_chetrf.c
4  *
5  * PaStiX chetrf StarPU wrapper.
6  *
7  * @copyright 2016-2023 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
8  * Univ. Bordeaux. All rights reserved.
9  *
10  * @version 6.3.2
11  * @author Mathieu Faverge
12  * @author Pierre Ramet
13  * @author Alycia Lisito
14  * @author Nolan Bredel
15  * @author Tom Moenne-Loccoz
16  * @date 2023-11-07
17  * @generated from /builds/solverstack/pastix/sopalin/starpu/starpu_zhetrf.c, normal z -> c, Wed Dec 13 12:09:29 2023
18  *
19  * @addtogroup starpu_hetrf
20  * @{
21  *
22  **/
23 #include "common.h"
24 #include "blend/solver.h"
25 #include "sopalin/sopalin_data.h"
26 #include "pastix_ccores.h"
27 #include "pastix_starpu.h"
28 #include "pastix_cstarpu.h"
29 #include "timing.h"
30 
31 /**
32  *******************************************************************************
33  *
34  * @brief TODO
35  *
36  *******************************************************************************
37  *
38  * @param[in] sopalin_data
39  * TODO
40  *
41  * @param[in] cblk
42  * TODO
43  *
44  * @param[in] prio
45  * TODO
46  *
47  *******************************************************************************/
48 void
49 starpu_task_chetrfsp( sopalin_data_t *sopalin_data,
50  SolverCblk *cblk,
51  int prio )
52 {
53  SolverBlok *lblk, *blok;
54  pastix_int_t m;
55 
56  if ( cblk->cblktype & CBLK_TASKS_2D ) {
57  starpu_task_blok_chetrf( sopalin_data, cblk, prio );
58 
59  lblk = cblk[1].fblokptr;
60  for ( blok = cblk->fblokptr + 1, m = 0; blok < lblk; blok++, m++ ) {
61 
64  cblk, blok, prio );
65 
66  /* Skip blocks facing the same cblk */
67  while ( ( blok < lblk ) &&
68  ( blok[0].fcblknm == blok[1].fcblknm ) &&
69  ( blok[0].lcblknm == blok[1].lcblknm ) )
70  {
71  blok++;
72  }
73  }
74  }
75  else {
76  starpu_task_cblk_chetrfsp( sopalin_data, cblk, prio );
77  }
78 }
79 
80 /**
81  *******************************************************************************
82  *
83  * @brief TODO
84  *
85  *******************************************************************************
86  *
87  * @param[in] sopalin_data
88  * TODO
89  *
90  * @param[in] cblk
91  * TODO
92  *
93  * @param[in] fcblk
94  * TODO
95  *
96  * @param[in] blokA
97  * TODO
98  *
99  * @param[in] prio
100  * TODO
101  *
102  *******************************************************************************/
103 void
104 starpu_task_hetrf_cgemmsp( sopalin_data_t *sopalin_data,
105  SolverCblk *cblk,
106  SolverBlok *blokB,
107  SolverCblk *fcblk,
108  int prio )
109 {
110  const SolverBlok *blokA, *lblk;
111  lblk = cblk[1].fblokptr;
112 
113  if ( cblk->cblktype & CBLK_TASKS_2D ) {
115  cblk, blokB, prio );
116 
117  for ( blokA = blokB; blokA < lblk; blokA++ ) {
119  cblk, fcblk, blokA, blokB, prio );
120 
121  /* Skip A blocks facing the same cblk */
122  while ( ( blokA < lblk ) &&
123  ( blokA[0].fcblknm == blokA[1].fcblknm ) &&
124  ( blokA[0].lcblknm == blokA[1].lcblknm ) )
125  {
126  blokA++;
127  }
128  }
129 
130  /* We don't need the copy of the block B any more */
131  starpu_data_unregister_submit( blokB->handler[1] );
132  blokB->handler[1] = NULL;
133  }
134  else {
136  cblk, blokB, fcblk, prio );
137  }
138 }
139 
140 /**
141  *******************************************************************************
142  *
143  * @brief Perform a sparse LDL^h factorization with 1D kernels.
144  *
145  * The function performs the LDL^h factorization of a sparse hermitian matrix A.
146  * The factorization has the form
147  *
148  * \f[ A = L \times D \times L^h \f]
149  *
150  * where L is a sparse lower triangular matrix unitary on the diagonal, and D a
151  * diagonal matrix.
152  *
153  *******************************************************************************
154  *
155  * @param[inout] sopalin_data
156  * Solver matrix information structure that will guide the algorithm.
157  *
158  * @param[inout] desc
159  * StarPU descriptor of the sparse matrix.
160  *
161  ******************************************************************************/
162 void
163 starpu_chetrf_sp1dplus_rl( sopalin_data_t *sopalin_data,
165 {
166  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
167  SolverCblk *cblk, *fcblk;
168  SolverBlok *blok, *lblk;
169  pastix_int_t k, m, cblknbr, cblk_n;
170 
171  cblknbr = solvmtx->cblknbr;
172  cblk = solvmtx->cblktab;
173  for (k=0; k<solvmtx->cblknbr; k++, cblk++){
174 
175  /* Do not handle the 1D layout case with runtimes due to gemm update */
176  assert( cblk->cblktype & CBLK_LAYOUT_2D );
177 
178  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
179  break;
180  }
181 
182  starpu_task_cblk_chetrfsp( sopalin_data, cblk,
183  cblknbr - k );
184 
185  blok = cblk->fblokptr + 1; /* this diagonal block */
186  lblk = cblk[1].fblokptr; /* the next diagonal block */
187 
188  /* if there are off-diagonal supernodes in the column */
189  for(m=0; blok < lblk; blok++, m++ )
190  {
191  fcblk = (solvmtx->cblktab + blok->fcblknm);
192  cblk_n = fcblk - solvmtx->cblktab;
193 
194  /* Update on L */
196  cblk, blok, fcblk,
197  cblknbr - pastix_imin( k + m, cblk_n ) );
198  }
199 
200  /* Unregister the temporary workspace generated by hetrf */
201  starpu_data_unregister_submit( cblk->handler[1] );
202  cblk->handler[1] = NULL;
203 
205  }
206  (void)desc;
207 }
208 
209 /**
210  *******************************************************************************
211  *
212  * @brief Perform a sparse LDL^h factorization with 1D kernels.
213  *
214  * The function performs the LDL^h factorization of a sparse hermitian matrix A.
215  * The factorization has the form
216  *
217  * \f[ A = L \times D \times L^h \f]
218  *
219  * where L is a sparse lower triangular matrix unitary on the diagonal, and D a
220  * diagonal matrix.
221  *
222  *******************************************************************************
223  *
224  * @param[inout] sopalin_data
225  * Solver matrix information structure that will guide the algorithm.
226  *
227  * @param[inout] desc
228  * StarPU descriptor of the sparse matrix.
229  *
230  ******************************************************************************/
231 void
232 starpu_chetrf_sp1dplus_ll( sopalin_data_t *sopalin_data,
234 {
235  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
236  SolverCblk *cblk, *fcblk, *lcblk;
237  SolverBlok *blok;
238  pastix_int_t k, m, cblknbr, cblk_n;
239 
240  cblknbr = solvmtx->cblknbr;
241  cblk = solvmtx->cblktab;
242  for (k=0; k<solvmtx->cblknbr; k++, cblk++){
243 
244  /* Do not handle the 1D layout case with runtimes due to gemm update */
245  assert( cblk->cblktype & CBLK_LAYOUT_2D );
246 
247  for ( m = cblk[0].brownum; m < cblk[1].brownum; m++ ) {
248  blok = solvmtx->bloktab + solvmtx->browtab[m];
249  lcblk = solvmtx->cblktab + blok->lcblknm;
250 
251  if ( lcblk->cblktype & CBLK_IN_SCHUR ) {
252  break;
253  }
254 
255  fcblk = solvmtx->cblktab + blok->fcblknm;
256  cblk_n = fcblk - solvmtx->cblktab;
257 
258  assert( fcblk == cblk );
259 
260  /* Update on L */
262  lcblk, blok, cblk,
263  cblknbr - pastix_imin( k + m, cblk_n ) );
264  }
265 
266  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
267  continue;
268  }
269 
270  starpu_task_cblk_chetrfsp( sopalin_data, cblk,
271  cblknbr - k );
272  }
273 
274  cblk = solvmtx->cblktab;
275  for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
276  /* Unregister the temporary workspace generated by hetrf */
277  starpu_data_unregister_submit( cblk->handler[1] );
278  cblk->handler[1] = NULL;
279 
281  }
282  (void)desc;
283 }
284 
285 /**
286  *******************************************************************************
287  *
288  * @brief Perform a sparse LDL^h factorization with 1D and 2D kernels.
289  *
290  * The function performs the LDL^h factorization of a sparse hermitian matrix A.
291  * The factorization has the form
292  *
293  * \f[ A = L \times D \times L^h \f]
294  *
295  * where L is a sparse lower triangular matrix unitary on the diagonal, and D a
296  * diagonal matrix.
297  *
298  *******************************************************************************
299  *
300  * @param[inout] sopalin_data
301  * Solver matrix information structure that will guide the algorithm.
302  *
303  * @param[inout] desc
304  * StarPU descriptor of the sparse matrix.
305  *
306  ******************************************************************************/
307 void
308 starpu_chetrf_sp2d_rl( sopalin_data_t *sopalin_data,
310 {
311  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
312  SolverCblk *cblk, *fcblk;
313  SolverBlok *blok, *lblk;
314  pastix_int_t k, m, cblknbr, cblk_n;
315 
316  cblknbr = solvmtx->cblknbr;
317 
318  /* Let's submit all 1D tasks first */
319  cblk = solvmtx->cblktab;
320  for ( k = 0; k <= solvmtx->cblkmax1d; k++, cblk++ ) {
321 
322  /* Do not handle the 1D layout case with runtimes due to gemm update */
323  assert( cblk->cblktype & CBLK_LAYOUT_2D );
324 
325  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
326  break;
327  }
328 
329  if ( cblk->cblktype & CBLK_TASKS_2D ) {
330  continue;
331  }
332 
333  starpu_task_chetrfsp( sopalin_data, cblk, cblknbr - k );
334 
335  blok = cblk->fblokptr + 1; /* this diagonal block */
336  lblk = cblk[1].fblokptr; /* the next diagonal block */
337 
338  /* if there are off-diagonal supernodes in the column */
339  for(m=0; blok < lblk; blok++, m++ )
340  {
341  fcblk = (solvmtx->cblktab + blok->fcblknm);
342  cblk_n = fcblk - solvmtx->cblktab;
343 
344  starpu_task_hetrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
345  cblknbr - pastix_imin( k + m, cblk_n ) );
346  }
347 
348  /* Unregister the temporary data generated by the hetrf kernel */
349  starpu_data_unregister_submit( cblk->handler[1] );
350  cblk->handler[1] = NULL;
351 
353  }
354 
355  /* Now we submit all 2D tasks */
356  cblk = solvmtx->cblktab + solvmtx->cblkmin2d;
357  for ( k = solvmtx->cblkmin2d; k < solvmtx->cblknbr; k++, cblk++ ) {
358 
359  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
360  continue;
361  }
362 
363  if ( ! ( cblk->cblktype & CBLK_TASKS_2D ) ) {
364  continue; /* skip 1D cblk */
365  }
366 
367  starpu_task_chetrfsp( sopalin_data, cblk, cblknbr - k );
368 
369  lblk = cblk[1].fblokptr;
370 
371  for ( blok = cblk->fblokptr + 1, m = 0; blok < lblk; blok++, m++ ) {
372  fcblk = ( solvmtx->cblktab + blok->fcblknm );
373  cblk_n = ( cblk->cblktype & CBLK_TASKS_2D ) ? blok->fcblknm : fcblk - solvmtx->cblktab;
374 
375  starpu_task_hetrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
376  cblknbr - pastix_imin( k + m, cblk_n ) );
377 
378  /* Skip blocks facing the same cblk */
379  while( ( blok < lblk ) &&
380  ( blok[0].fcblknm == blok[1].fcblknm ) &&
381  ( blok[0].lcblknm == blok[1].lcblknm ) )
382  {
383  blok++;
384  }
385  }
386 
388  }
389 
390  (void)desc;
391 }
392 
393 /**
394  *******************************************************************************
395  *
396  * @brief Perform a sparse LDL^h factorization with 1D and 2D kernels.
397  *
398  * The function performs the LDL^h factorization of a sparse hermitian matrix A.
399  * The factorization has the form
400  *
401  * \f[ A = L \times D \times L^h \f]
402  *
403  * where L is a sparse lower triangular matrix unitary on the diagonal, and D a
404  * diagonal matrix.
405  *
406  *******************************************************************************
407  *
408  * @param[inout] sopalin_data
409  * Solver matrix information structure that will guide the algorithm.
410  *
411  * @param[inout] desc
412  * StarPU descriptor of the sparse matrix.
413  *
414  ******************************************************************************/
415 void
416 starpu_chetrf_sp2d_ll( sopalin_data_t *sopalin_data,
418 {
419  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
420  SolverCblk *cblk, *fcblk;
421  SolverBlok *blok = NULL;
422  SolverBlok *blok_prev;
423  pastix_int_t k, m, cblknbr;
424 
425  cblknbr = solvmtx->cblknbr;
426  fcblk = solvmtx->cblktab;
427 
428  for ( k = 0; k < cblknbr; k++, fcblk++ ) {
429 
430  for ( m = fcblk[0].brownum; m < fcblk[1].brownum; m++ ) {
431  blok_prev = blok;
432  blok = solvmtx->bloktab + solvmtx->browtab[m];
433  cblk = solvmtx->cblktab + blok->lcblknm;
434 
435  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
436  continue;
437  }
438 
439  if( ( cblk->cblktype & CBLK_TASKS_2D ) &&
440  ( blok_prev != NULL ) &&
441  ( blok_prev->fcblknm == blok->fcblknm ) &&
442  ( blok_prev->lcblknm == blok->lcblknm ) )
443  {
444  continue;
445  }
446 
447  starpu_task_hetrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
448  cblknbr - k );
449  }
450 
451  if ( fcblk->cblktype & CBLK_IN_SCHUR ) {
452  continue;
453  }
454 
455  starpu_task_chetrfsp( sopalin_data, fcblk, cblknbr - k );
456  }
457 
458  cblk = solvmtx->cblktab;
459  for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
460  /* Unregister the temporary workspace generated by hetrf */
461  if ( cblk->handler[1] != NULL ) {
462  starpu_data_unregister_submit( cblk->handler[1] );
463  cblk->handler[1] = NULL;
464  }
465 
467  }
468 
469  (void)desc;
470 }
471 
472 /**
473  *******************************************************************************
474  *
475  * @brief Perform a sparse LDL^h factorization using StarPU runtime.
476  *
477  * The function performs the LDL^h factorization of a sparse hermitian matrix A.
478  * The factorization has the form
479  *
480  * \f[ A = L \times D \times L^h \f]
481  *
482  * where L is a sparse lower triangular matrix unitary on the diagonal, and D a
483  * diagonal matrix.
484  *
485  * The algorithm is automatically chosen between the 1D and 2D version based on
486  * the API parameter IPARM_TASKS2D_LEVEL. If IPARM_TASKS2D_LEVEL != 0
487  * the 2D scheme is applied, the 1D otherwise.
488  *
489  *******************************************************************************
490  *
491  * @param[inout] pastix_data
492  * The pastix_data structure that describes the solver instance.
493  *
494  * @param[inout] sopalin_data
495  * Solver matrix information structure that will guide the algorithm.
496  *
497  ******************************************************************************/
498 void
500  sopalin_data_t *sopalin_data )
501 {
502  starpu_sparse_matrix_desc_t *sdesc = sopalin_data->solvmtx->starpu_desc;
503  float sub = 0.;
504  float com = 0.;
505 
506  /*
507  * Start StarPU if not already started
508  */
509  if (pastix_data->starpu == NULL) {
510  int argc = 0;
511  pastix_starpu_init( pastix_data, &argc, NULL, NULL );
512  }
513 
514  if ( sdesc == NULL ) {
515  /* Create the matrix descriptor */
516  starpu_sparse_matrix_init( sopalin_data->solvmtx,
518  pastix_data->inter_node_procnbr,
519  pastix_data->inter_node_procnum,
520  PastixComplex32 );
521  sdesc = sopalin_data->solvmtx->starpu_desc;
522  }
523 
524  starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
525 #if defined(STARPU_USE_FXT)
526  if (pastix_data->iparm[IPARM_TRACE] & PastixTraceNumfact) {
527  starpu_fxt_start_profiling();
528  }
529 #endif
530 #if defined(PASTIX_STARPU_STATS)
531  clockStart( sub );
532 #else
533  starpu_resume();
534 #endif
535  /*
536  * Select 1D or 2D algorithm based on 2d tasks level
537  */
538  if ( pastix_data->iparm[IPARM_TASKS2D_LEVEL] != 0 )
539  {
540  if ( pastix_data->iparm[IPARM_FACTO_LOOK_SIDE] == PastixFactLeftLooking ) {
541  starpu_chetrf_sp2d_ll( sopalin_data, sdesc );
542  }
543  else {
544  starpu_chetrf_sp2d_rl( sopalin_data, sdesc );
545  }
546  }
547  else
548  {
549  if ( pastix_data->iparm[IPARM_FACTO_LOOK_SIDE] == PastixFactLeftLooking ) {
550  starpu_chetrf_sp1dplus_ll( sopalin_data, sdesc );
551  }
552  else {
553  starpu_chetrf_sp1dplus_rl( sopalin_data, sdesc );
554  }
555  }
556 
558 #if defined(PASTIX_STARPU_STATS)
559  clockStop( sub );
560  clockStart( com );
561  starpu_resume();
562 #endif
563  starpu_task_wait_for_all();
564 #if defined(PASTIX_WITH_MPI)
565  starpu_mpi_wait_for_all( pastix_data->pastix_comm );
566  starpu_mpi_barrier( pastix_data->inter_node_comm );
567 #endif
568  starpu_pause();
569 #if defined(STARPU_USE_FXT)
570  if (pastix_data->iparm[IPARM_TRACE] & PastixTraceNumfact) {
571  starpu_fxt_stop_profiling();
572  }
573 #endif
574  starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
575 #if defined(PASTIX_STARPU_STATS)
576  clockStop( com );
577  print_stats( sub, com, pastix_data->solvmatr );
578 #endif
579 
580  (void)com;
581  (void)sub;
582  return;
583 }
584 
585 /**
586  *@}
587  */
BEGIN_C_DECLS typedef int pastix_int_t
Definition: datatypes.h:51
#define PastixHermitian
Definition: api.h:460
@ PastixLCoef
Definition: api.h:478
@ PastixUCoef
Definition: api.h:479
@ IPARM_TASKS2D_LEVEL
Definition: api.h:90
@ IPARM_FACTO_LOOK_SIDE
Definition: api.h:100
@ IPARM_TRACE
Definition: api.h:44
@ PastixUpper
Definition: api.h:466
@ PastixRight
Definition: api.h:496
@ PastixNonUnit
Definition: api.h:487
@ PastixConjTrans
Definition: api.h:447
@ PastixNoTrans
Definition: api.h:445
@ PastixTrans
Definition: api.h:446
@ PastixFactLeftLooking
Definition: api.h:326
@ PastixTraceNumfact
Definition: api.h:211
void starpu_sparse_matrix_getoncpu(starpu_sparse_matrix_desc_t *desc)
Submit asynchronous calls to retrieve the data on main memory.
void starpu_task_blok_chetrf(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
TODO.
void starpu_sparse_matrix_init(SolverMatrix *solvmtx, pastix_mtxtype_t mtxtype, int nodes, int myrank, pastix_coeftype_t flttype)
Generate the StarPU descriptor of the sparse matrix.
void starpu_task_blok_cscalo(sopalin_data_t *sopalin_data, pastix_trans_t trans, const SolverCblk *cblk, SolverBlok *blok, int prio)
TODO.
void pastix_starpu_init(pastix_data_t *pastix, int *argc, char **argv[], const int *bindtab)
Startup the StarPU runtime system.
Definition: starpu.c:92
void starpu_task_blok_ctrsmsp(sopalin_data_t *sopalin_data, pastix_coefside_t coef, pastix_side_t side, pastix_uplo_t uplo, pastix_trans_t trans, pastix_diag_t diag, const SolverCblk *cblk, SolverBlok *blok, int prio)
StarPU GPU implementation.
void starpu_task_cblk_cgemmsp(sopalin_data_t *sopalin_data, pastix_coefside_t sideA, pastix_coefside_t sideB, pastix_trans_t trans, const SolverCblk *cblk, const SolverBlok *blok, SolverCblk *fcblk, int prio)
StarPU GPU implementation.
void starpu_sparse_cblk_wont_use(pastix_coefside_t coef, SolverCblk *cblk)
Submit asynchronous calls to retrieve the data on main memory.
void starpu_task_blok_cgemmsp(sopalin_data_t *sopalin_data, pastix_coefside_t sideA, pastix_coefside_t sideB, pastix_trans_t trans, SolverCblk *cblk, SolverCblk *fcblk, const SolverBlok *blokA, const SolverBlok *blokB, int prio)
StarPU GPU implementation.
void starpu_task_cblk_chetrfsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
TODO.
StarPU descriptor stucture for the sparse matrix.
PASTIX_Comm pastix_comm
Definition: pastixdata.h:75
int inter_node_procnum
Definition: pastixdata.h:83
SolverMatrix * solvmatr
Definition: pastixdata.h:102
int inter_node_procnbr
Definition: pastixdata.h:82
void * starpu
Definition: pastixdata.h:87
pastix_int_t * iparm
Definition: pastixdata.h:69
PASTIX_Comm inter_node_comm
Definition: pastixdata.h:77
Main PaStiX data structure.
Definition: pastixdata.h:67
void starpu_chetrf_sp1dplus_rl(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LDL^h factorization with 1D kernels.
void starpu_task_hetrf_cgemmsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, SolverBlok *blokB, SolverCblk *fcblk, int prio)
TODO.
void starpu_chetrf_sp2d_rl(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LDL^h factorization with 1D and 2D kernels.
void starpu_chetrf_sp2d_ll(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LDL^h factorization with 1D and 2D kernels.
void starpu_chetrf_sp1dplus_ll(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LDL^h factorization with 1D kernels.
void starpu_task_chetrfsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
TODO.
Definition: starpu_chetrf.c:49
void starpu_chetrf(pastix_data_t *pastix_data, sopalin_data_t *sopalin_data)
Perform a sparse LDL^h factorization using StarPU runtime.
pastix_int_t cblkmin2d
Definition: solver.h:215
void * handler[2]
Definition: solver.h:138
pastix_int_t brownum
Definition: solver.h:166
pastix_int_t fcblknm
Definition: solver.h:140
pastix_int_t cblknbr
Definition: solver.h:208
SolverBlok *restrict bloktab
Definition: solver.h:223
pastix_int_t cblkmax1d
Definition: solver.h:214
SolverBlok * fblokptr
Definition: solver.h:163
pastix_int_t *restrict browtab
Definition: solver.h:224
pastix_int_t lcblknm
Definition: solver.h:139
SolverCblk *restrict cblktab
Definition: solver.h:222
void * handler[2]
Definition: solver.h:173
int8_t cblktype
Definition: solver.h:159
Solver block structure.
Definition: solver.h:137
Solver column block structure.
Definition: solver.h:156
Solver column block structure.
Definition: solver.h:200