PaStiX Handbook  6.2.1
cpucblk_sinit.c
Go to the documentation of this file.
1 /**
2  *
3  * @file cpucblk_sinit.c
4  *
5  * Precision dependent coeficient array initialization routines.
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 Xavier Lacoste
12  * @author Pierre Ramet
13  * @author Mathieu Faverge
14  * @author Esragul Korkmaz
15  * @author Tony Delarue
16  * @date 2021-03-30
17  *
18  * @generated from /builds/solverstack/pastix/kernels/cpucblk_zinit.c, normal z -> s, Tue Apr 12 09:38:40 2022
19  *
20  **/
21 #include "common/common.h"
22 #include "blend/solver.h"
23 #include "bcsc/bcsc.h"
24 #include "pastix_scores.h"
25 #include "pastix_slrcores.h"
26 
27 /**
28  *******************************************************************************
29  *
30  * @brief Initialize a lrblock structure from a workspace from a specific block to the end of all
31  * blocks.
32  *
33  * The lrblock structure must be allocated before.
34  *
35  *******************************************************************************
36  *
37  * @param[inout] cblk
38  * The column block associated to the initialization.
39  *
40  * @param[in] blok
41  * The block representation associated to the initialization.
42  *
43  * @param[in] lrblok
44  * The structure blok to initialize. Must be allocated before.
45  *
46  * @param[in] ws
47  * The workspace associated with the data that will be used for initialize lrblok.
48  *
49  *******************************************************************************/
50 void
52  const SolverBlok *blok,
53  pastix_lrblock_t *lrblok,
54  float *ws )
55 {
56  SolverBlok *lblok = cblk[1].fblokptr;
57  pastix_int_t fcblknm = blok->fcblknm;
58  pastix_int_t ncols = cblk_colnbr( cblk );
59 
60  /* H then split */
61  assert( cblk->cblktype & CBLK_LAYOUT_2D );
62  assert( lrblok != NULL );
63 
64  for (; (blok < lblok) && (blok->fcblknm == fcblknm); blok++, lrblok++)
65  {
66  pastix_int_t nrows = blok_rownbr( blok );
67  lrblok->rk = -1;
68  lrblok->rkmax = nrows;
69  lrblok->u = ws;
70  lrblok->v = NULL;
71 
72  ws += nrows * ncols;
73  }
74 }
75 
76 /**
77  *******************************************************************************
78  *
79  * @brief Initialize lrblock structure from a workspace from all blocks of the cblk associated.
80  *
81  * The lrblock structure must be allocated before.
82  *
83  *******************************************************************************
84  *
85  * @param[inout] cblk
86  * The column block associated to the initialization.
87  *
88  * @param[in] lrblok
89  * The structure blok to initialize. Must be allocated before.
90  *
91  * @param[in] ws
92  * The workspace associated with the data that will be used for initialize lrblok.
93  *
94  *******************************************************************************/
95 void
97  pastix_lrblock_t *lrblok,
98  float *ws )
99 {
100  pastix_int_t ncols = cblk_colnbr( cblk );
101  const SolverBlok *blok = cblk[0].fblokptr;
102  const SolverBlok *lblok = cblk[1].fblokptr;
103 
104  /* H then split */
105  assert( cblk->cblktype & CBLK_LAYOUT_2D );
106  assert( lrblok != NULL );
107 
108  for (; blok<lblok; blok++, lrblok++)
109  {
110  pastix_int_t nrows = blok_rownbr( blok );
111  lrblok->rk = -1;
112  lrblok->rkmax = nrows;
113  lrblok->u = ws;
114  lrblok->v = NULL;
115 
116  ws += nrows * ncols;
117  }
118 }
119 
120 /**
121  *******************************************************************************
122  *
123  * @brief Allocate the cblk structure to store the coefficient
124  *
125  * When stored in low-rank format, the data pointer in the low-rank structure of
126  * each block must be initialized.
127  * This routines performs only the allocation and is thread-safe if called in
128  * parallel on the Lower and upper part.
129  *
130  *******************************************************************************
131  *
132  * @param[in] side
133  * Define which side of the matrix must be initialized.
134  * @arg PastixLCoef if lower part only
135  * @arg PastixUCoef if upper part only
136  * @arg PastixLUCoef if both sides.
137  *
138  * @param[inout] cblk
139  * The column block to allocate.
140  *
141  *******************************************************************************/
142 void
144  SolverCblk *cblk,
145  int rkmax )
146 {
147  pastix_int_t ncols = cblk_colnbr( cblk );
148  pastix_lrblock_t *LRblocks = NULL;
149  SolverBlok *blok = cblk[0].fblokptr;
150  SolverBlok *lblok = cblk[1].fblokptr;
151  size_t size = lblok - blok;
152 
153  /* H then split */
154  assert( cblk->cblktype & CBLK_LAYOUT_2D );
155 
156  LRblocks = blok->LRblock[0];
157 
158  if ( LRblocks == NULL ) {
159  /* One allocation per cblk */
160  LRblocks = malloc( 2 * size * sizeof(pastix_lrblock_t) );
161  memset( LRblocks, 0, 2 * size * sizeof(pastix_lrblock_t) );
162  if (!pastix_atomic_cas_xxb( &(blok->LRblock[0]), (uint64_t)NULL, (uint64_t)LRblocks, sizeof(void*) )) {
163  free( LRblocks );
164  LRblocks = blok->LRblock[0];
165  }
166  }
167  assert( LRblocks != NULL );
168 
169  for (; blok<lblok; blok++)
170  {
171  pastix_int_t nrows = blok_rownbr( blok );
172  blok->LRblock[0] = LRblocks;
173  blok->LRblock[1] = LRblocks + size;
174 
175  if ( side != PastixUCoef ) {
176  core_slralloc( nrows, ncols, rkmax, blok->LRblock[0] );
177  }
178 
179  if ( side != PastixLCoef ) {
180  core_slralloc( nrows, ncols, rkmax, blok->LRblock[1] );
181  }
182  LRblocks++;
183  }
184 
185  /* Backup the fact that the cblk has been initialized */
186  if ( side != PastixUCoef ) {
187  cblk->lcoeftab = (void*)-1;
188  }
189  if ( side != PastixLCoef ) {
190  cblk->ucoeftab = (void*)-1;
191  }
192 }
193 
194 /**
195  *******************************************************************************
196  *
197  * @brief Allocate the cblk structure to store the coefficient
198  *
199  * When stored in low-rank format, the data pointer in the low-rank structure of
200  * each block must be initialized.
201  * This routines performs only the allocation and is thread-safe if called in
202  * parallel on the Lower and upper part.
203  *
204  *******************************************************************************
205  *
206  * @param[in] side
207  * Define which side of the matrix must be initialized.
208  * @arg PastixLCoef if lower part only
209  * @arg PastixUCoef if upper part only
210  * @arg PastixLUCoef if both sides.
211  *
212  * @param[inout] cblk
213  * The column block to allocate.
214  *
215  *******************************************************************************/
216 void
218  SolverCblk *cblk )
219 {
220  pastix_int_t ncols = cblk_colnbr( cblk );
221  size_t coefnbr = cblk->stride * ncols;
222 
223  if ( side == PastixLCoef ) {
224  assert( cblk->lcoeftab == NULL );
225  MALLOC_INTERN( cblk->lcoeftab, coefnbr, float );
226  memset( cblk->lcoeftab, 0, coefnbr * sizeof(float) );
227  }
228  else {
229  assert( cblk->lcoeftab == NULL );
230  assert( cblk->ucoeftab == NULL );
231 
232  MALLOC_INTERN( cblk->lcoeftab, 2 * coefnbr, float );
233  memset( cblk->lcoeftab, 0, 2 * coefnbr * sizeof(float) );
234 
235  cblk->ucoeftab = (float *)cblk->lcoeftab + coefnbr;
236  assert( cblk->ucoeftab );
237  }
238  assert( cblk->lcoeftab );
239 }
240 
241 /**
242  *******************************************************************************
243  *
244  * @brief Allocate the cblk structure to store the coefficient
245  *
246  * When stored in low-rank format, the data pointer in the low-rank structure of
247  * each block must be initialized.
248  * This routines performs only the allocation and is thread-safe if called in
249  * parallel on the Lower and upper part.
250  *
251  *******************************************************************************
252  *
253  * @param[in] side
254  * Define which side of the matrix must be initialized.
255  * @arg PastixLCoef if lower part only
256  * @arg PastixUCoef if upper part only
257  * @arg PastixLUCoef if both sides.
258  *
259  * @param[inout] cblk
260  * The column block to allocate.
261  *
262  *******************************************************************************/
263 void
265  SolverCblk *cblk )
266 {
267  /* Make sure they have the correct values */
268  assert( PastixLCoef == 0 );
269  assert( PastixUCoef == 1 );
270 
271  pastix_cblk_lock( cblk );
272 
273  /* Shift to play with bitmasks */
274  side += 1;
275  if ( cblk->lcoeftab != NULL ) {
276  side &= ( ~(PastixLCoef+1) );
277  }
278  if ( cblk->ucoeftab != NULL ) {
279  side &= ( ~(PastixUCoef+1) );
280  }
281  if ( !side ) {
282  pastix_cblk_unlock( cblk );
283  return;
284  }
285  side -= 1;
286 
287  if ( cblk->cblktype & CBLK_COMPRESSED ) {
288  cpucblk_salloc_lr( side, cblk, cblk->cblktype & CBLK_FANIN ? 0 : -1 );
289  }
290  else {
291  cpucblk_salloc_fr( side, cblk );
292  }
293  pastix_cblk_unlock( cblk );
294 }
295 
296 /**
297  *******************************************************************************
298  *
299  * @brief Free the cblk structure that store the coefficient
300  *
301  * This routines performs the free and is thread-safe if called in
302  * parallel on the Lower and upper part.
303  *
304  *******************************************************************************
305  *
306  * @param[in] side
307  * Define which side of the matrix must be initialized.
308  * @arg PastixLCoef if lower part only
309  * @arg PastixUCoef if upper part only
310  * @arg PastixLUCoef if both sides.
311  *
312  * @param[inout] cblk
313  * The column block to free.
314  *
315  *******************************************************************************/
316 void
318  SolverCblk *cblk )
319 {
320  pastix_cblk_lock( cblk );
321  if ( (side != PastixUCoef) && (cblk->lcoeftab != NULL) ) {
322 
323  if ( cblk->cblktype & CBLK_COMPRESSED ) {
324  SolverBlok *blok = cblk[0].fblokptr;
325  SolverBlok *lblok = cblk[1].fblokptr;
326 
327  assert( blok->LRblock[0] != NULL );
328  for (; blok<lblok; blok++) {
329  core_slrfree(blok->LRblock[0]);
330  }
331 
332  if ( cblk->lcoeftab != (void*)-1 ) {
333  memFree_null( cblk->lcoeftab );
334  }
335  }
336  else {
337  memFree_null( cblk->lcoeftab );
338  }
339  cblk->lcoeftab = NULL;
340  }
341  if ( (side != PastixLCoef) && (cblk->ucoeftab != NULL) ) {
342 
343  if ( cblk->cblktype & CBLK_COMPRESSED ) {
344  SolverBlok *blok = cblk[0].fblokptr;
345  SolverBlok *lblok = cblk[1].fblokptr;
346 
347  assert( blok->LRblock[1] != NULL );
348  for (; blok<lblok; blok++) {
349  core_slrfree(blok->LRblock[1]);
350  }
351  }
352  cblk->ucoeftab = NULL;
353  }
354  if ( (cblk->cblktype & CBLK_COMPRESSED) &&
355  (cblk->lcoeftab == NULL) &&
356  (cblk->ucoeftab == NULL) )
357  {
358  free( cblk->fblokptr->LRblock[0] );
359  cblk->fblokptr->LRblock[0] = NULL;
360  cblk->fblokptr->LRblock[1] = NULL;
361  }
362  pastix_cblk_unlock( cblk );
363 }
364 
365 /**
366  *******************************************************************************
367  *
368  * @brief Initialize the full-rank coeftab structure from the internat bcsc.
369  *
370  *******************************************************************************
371  *
372  * @param[in] side
373  * Define which side of the matrix must be initialized.
374  * @arg PastixLCoef if lower part only
375  * @arg PastixUCoef if upper part only
376  * @arg PastixLUCoef if both sides.
377  *
378  * @param[in] solvmtx
379  * PaStiX structure to store numerical data and flags
380  *
381  * @param[in] bcsc
382  * The internal bcsc structure that hold the graph with permutation
383  * stored by cblk.
384  *
385  * @param[in] itercblk
386  * The index of the cblk to fill in both bcsc and solvmtx structures.
387  *
388  *******************************************************************************/
389 static inline void
391  const SolverMatrix *solvmtx,
392  const pastix_bcsc_t *bcsc,
393  pastix_int_t itercblk )
394 {
395  SolverCblk *solvcblk = solvmtx->cblktab + itercblk;
396  const bcsc_cblk_t *csccblk = bcsc->cscftab + solvcblk->bcscnum;
397  SolverBlok *solvblok;
398  SolverBlok *lsolvblok = (solvcblk+1)->fblokptr;
399  float *lcoeftab = solvcblk->lcoeftab;
400  float *ucoeftab = solvcblk->ucoeftab;
401  float *Lvalues = bcsc->Lvalues;
402  float *Uvalues = bcsc->Uvalues;
403  pastix_int_t ldd = solvcblk->stride;
404  pastix_int_t itercoltab, iterval, coefindx;
405  int is2d = solvcblk->cblktype & CBLK_LAYOUT_2D;
406 
407  assert( (side != PastixUCoef) || (ucoeftab != NULL) );
408 
409  for (itercoltab=0; itercoltab<csccblk->colnbr; itercoltab++)
410  {
411  pastix_int_t frow = csccblk->coltab[itercoltab];
412  pastix_int_t lrow = csccblk->coltab[itercoltab+1];
413  solvblok = solvcblk->fblokptr;
414  if ( is2d ) {
415  ldd = blok_rownbr( solvblok );
416  }
417 
418  for (iterval=frow; iterval<lrow; iterval++)
419  {
420  pastix_int_t rownum = bcsc->rowtab[iterval];
421 
422  /* If values in the lower part of the matrix */
423  if (rownum >= (solvcblk->fcolnum+itercoltab))
424  {
425  while ((solvblok < lsolvblok) &&
426  ((solvblok->lrownum < rownum) ||
427  (solvblok->frownum > rownum)))
428  {
429  solvblok++;
430  if ( is2d ) {
431  ldd = blok_rownbr( solvblok );
432  }
433  }
434 
435  if ( solvblok < lsolvblok )
436  {
437  coefindx = solvblok->coefind;
438  coefindx += rownum - solvblok->frownum; /* Row shift */
439  coefindx += itercoltab * ldd; /* Column shift */
440  pastix_cblk_lock( solvcblk );
441  solvblok->iluklvl = 0;
442  pastix_cblk_unlock( solvcblk );
443 
444  if ( side != PastixUCoef ) {
445  lcoeftab[coefindx] = Lvalues[iterval];
446  }
447 
448  if ( (side != PastixLCoef) &&
449  (rownum > (solvcblk->fcolnum + itercoltab)) )
450  {
451 #if defined(PRECISION_z) || defined(PRECISION_c)
452  if (bcsc->mtxtype == PastixSymmetric) {
453  ucoeftab[coefindx] = (Uvalues[iterval]);
454  }
455  else
456 #endif
457  {
458  ucoeftab[coefindx] = Uvalues[iterval];
459  }
460  }
461  }
462  else {
463 #if defined(PASTIX_DEBUG_COEFTAB)
464  fprintf(stderr, "cpucblk_sfillin: drop coeff from CSC c=%ld(%ld) l=%ld(%ld) cblk=%ld fcol=%ld lcol=%ld\n",
465  (long)solvcblk->fcolnum + itercoltab, (long)itercoltab,
466  (long)rownum, (long)iterval, (long)itercblk,
467  (long)solvcblk->fcolnum, (long)solvcblk->lcolnum );
468 #endif
469  }
470  }
471  }
472  }
473 }
474 
475 /**
476  *******************************************************************************
477  *
478  * @brief Initialize the low-rank coeftab structure from the internal bcsc.
479  *
480  *******************************************************************************
481  *
482  * @param[in] side
483  * Define which side of the matrix must be initialized.
484  * @arg PastixLCoef if lower part only
485  * @arg PastixUCoef if upper part only
486  * @arg PastixLUCoef if both sides.
487  *
488  * @param[in] solvmtx
489  * PaStiX structure to store numerical data and flags
490  *
491  * @param[in] bcsc
492  * The internal bcsc structure that hold the graph with permutation
493  * stored by cblk.
494  *
495  * @param[in] itercblk
496  * The index of the cblk to fill in both bcsc and solvmtx structures.
497  *
498  *******************************************************************************/
499 static inline void
501  const SolverMatrix *solvmtx,
502  const pastix_bcsc_t *bcsc,
503  pastix_int_t itercblk )
504 {
505  SolverCblk *solvcblk = solvmtx->cblktab + itercblk;
506  const bcsc_cblk_t *csccblk = bcsc->cscftab + solvcblk->bcscnum;
507  SolverBlok *solvblok;
508  SolverBlok *lsolvblok = (solvcblk+1)->fblokptr;
509  float *lcoeftab, *ucoeftab;
510  float *Lvalues = bcsc->Lvalues;
511  float *Uvalues = bcsc->Uvalues;
512  pastix_int_t itercoltab, iterval, coefindx, ldd;
513 
514  assert( solvcblk->cblktype & CBLK_LAYOUT_2D );
515 
516  for (itercoltab=0; itercoltab<csccblk->colnbr; itercoltab++)
517  {
518  pastix_int_t frow = csccblk->coltab[itercoltab];
519  pastix_int_t lrow = csccblk->coltab[itercoltab+1];
520 
521  solvblok = solvcblk->fblokptr;
522  ldd = blok_rownbr( solvblok );
523  lcoeftab = (float*)(solvblok->LRblock[0]->u);
524  ucoeftab = (float*)(solvblok->LRblock[1]->u);
525 
526  for (iterval=frow; iterval<lrow; iterval++)
527  {
528  pastix_int_t rownum = bcsc->rowtab[iterval];
529 
530  /* If values in the lower part of the matrix */
531  if (rownum >= (solvcblk->fcolnum+itercoltab))
532  {
533  while ((solvblok < lsolvblok) &&
534  ((solvblok->lrownum < rownum) ||
535  (solvblok->frownum > rownum)))
536  {
537  solvblok++;
538  ldd = blok_rownbr( solvblok );
539  lcoeftab = (float*)(solvblok->LRblock[0]->u);
540  ucoeftab = (float*)(solvblok->LRblock[1]->u);
541  }
542 
543  if ( solvblok < lsolvblok )
544  {
545  coefindx = rownum - solvblok->frownum; /* Row shift */
546  coefindx += itercoltab * ldd; /* Column shift */
547  pastix_cblk_lock( solvcblk );
548  solvblok->iluklvl = 0;
549  pastix_cblk_unlock( solvcblk );
550 
551  if ( side != PastixUCoef ) {
552  lcoeftab[coefindx] = Lvalues[iterval];
553  }
554 
555  if ( (side != PastixLCoef) &&
556  (rownum > (solvcblk->fcolnum + itercoltab)) )
557  {
558 #if defined(PRECISION_z) || defined(PRECISION_c)
559  if (bcsc->mtxtype == PastixSymmetric)
560  ucoeftab[coefindx] = (Uvalues[iterval]);
561  else
562 #endif
563  ucoeftab[coefindx] = Uvalues[iterval];
564  }
565  }
566  else {
567 #if defined(PASTIX_DEBUG_COEFTAB)
568  fprintf(stderr, "cpucblk_sfillin: drop coeff from CSC c=%ld(%ld) l=%ld(%ld) cblk=%ld fcol=%ld lcol=%ld\n",
569  (long)solvcblk->fcolnum + itercoltab, (long)itercoltab,
570  (long)rownum, (long)iterval, (long)itercblk,
571  (long)solvcblk->fcolnum, (long)solvcblk->lcolnum );
572 #endif
573  }
574  }
575  }
576  }
577 }
578 
579 /**
580  *******************************************************************************
581  *
582  * @brief Initialize the coeftab structure from the internal bcsc.
583  *
584  *******************************************************************************
585  *
586  * @param[in] side
587  * Define which side of the matrix must be initialized.
588  * @arg PastixLCoef if lower part only
589  * @arg PastixUCoef if upper part only
590  * @arg PastixLUCoef if both sides.
591  *
592  * @param[in] solvmtx
593  * PaStiX structure to store numerical data and flags
594  *
595  * @param[in] bcsc
596  * The internal bcsc structure that hold the graph with permutation
597  * stored by cblk.
598  *
599  * @param[in] itercblk
600  * The index of the cblk to fill in both bcsc and solvmtx structures.
601  *
602  *******************************************************************************/
603 void
605  const SolverMatrix *solvmtx,
606  const pastix_bcsc_t *bcsc,
607  pastix_int_t itercblk )
608 {
609  if ( (solvmtx->cblktab + itercblk)->cblktype & CBLK_COMPRESSED ) {
610  cpucblk_sfillin_lr( side, solvmtx, bcsc, itercblk );
611  }
612  else {
613  cpucblk_sfillin_fr( side, solvmtx, bcsc, itercblk );
614  }
615 }
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
cpucblk_salloc_fr
void cpucblk_salloc_fr(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_sinit.c:217
solver_cblk_s::fblokptr
SolverBlok * fblokptr
Definition: solver.h:134
cpucblk_sfree
void cpucblk_sfree(pastix_coefside_t side, SolverCblk *cblk)
Free the cblk structure that store the coefficient.
Definition: cpucblk_sinit.c:317
pastix_lrblock_s::v
void * v
Definition: pastix_lowrank.h:116
pastix_bcsc_s
Internal column block distributed CSC matrix.
Definition: bcsc.h:37
solver_cblk_s::stride
pastix_int_t stride
Definition: solver.h:135
pastix_lrblock_s::u
void * u
Definition: pastix_lowrank.h:115
pastix_bcsc_s::cscftab
bcsc_cblk_t * cscftab
Definition: bcsc.h:43
bcsc_cblk_s::coltab
pastix_int_t * coltab
Definition: bcsc.h:31
solver_cblk_s
Solver column block structure.
Definition: solver.h:127
pastix_coefside_t
enum pastix_coefside_e pastix_coefside_t
Data blocks used in the kernel.
core_slralloc
void core_slralloc(pastix_int_t M, pastix_int_t N, pastix_int_t rkmax, pastix_lrblock_t *A)
Allocate a low-rank matrix.
Definition: core_sgelrops.c:56
pastix_bcsc_s::Lvalues
void * Lvalues
Definition: bcsc.h:45
bcsc_cblk_s::colnbr
pastix_int_t colnbr
Definition: bcsc.h:29
solver_cblk_s::bcscnum
pastix_int_t bcscnum
Definition: solver.h:141
solver_blok_s
Solver block structure.
Definition: solver.h:107
cpucblk_salloc_lr
void cpucblk_salloc_lr(pastix_coefside_t side, SolverCblk *cblk, int rkmax)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_sinit.c:143
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
solver_cblk_s::ucoeftab
void * ucoeftab
Definition: solver.h:143
core_slrfree
void core_slrfree(pastix_lrblock_t *A)
Free a low-rank matrix.
Definition: core_sgelrops.c:116
solver_cblk_s::lcolnum
pastix_int_t lcolnum
Definition: solver.h:133
cpucblk_sfillin_fr
static void cpucblk_sfillin_fr(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk)
Initialize the full-rank coeftab structure from the internat bcsc.
Definition: cpucblk_sinit.c:390
pastix_bcsc_s::mtxtype
int mtxtype
Definition: bcsc.h:40
solver_blok_s::iluklvl
int iluklvl
Definition: solver.h:118
bcsc.h
solver_cblk_s::lcoeftab
void * lcoeftab
Definition: solver.h:142
pastix_scores.h
PastixUCoef
@ PastixUCoef
Definition: api.h:457
bcsc_cblk_s
Compressed colptr format for the bcsc.
Definition: bcsc.h:28
PastixLCoef
@ PastixLCoef
Definition: api.h:456
pastix_slrcores.h
pastix_bcsc_s::rowtab
pastix_int_t * rowtab
Definition: bcsc.h:44
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
solver_blok_s::lrownum
pastix_int_t lrownum
Definition: solver.h:113
pastix_lrblock_s::rk
int rk
Definition: pastix_lowrank.h:113
solver_cblk_s::cblktype
int8_t cblktype
Definition: solver.h:130
solver_cblk_s::fcolnum
pastix_int_t fcolnum
Definition: solver.h:132
solver_blok_s::LRblock
pastix_lrblock_t * LRblock[2]
Definition: solver.h:121
cpublok_salloc_lrws
void cpublok_salloc_lrws(const SolverCblk *cblk, const SolverBlok *blok, pastix_lrblock_t *lrblok, float *ws)
Initialize a lrblock structure from a workspace from a specific block to the end of all blocks.
Definition: cpucblk_sinit.c:51
pastix_lrblock_s::rkmax
int rkmax
Definition: pastix_lowrank.h:114
solver_blok_s::fcblknm
pastix_int_t fcblknm
Definition: solver.h:110
cpucblk_sfillin_lr
static void cpucblk_sfillin_lr(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk)
Initialize the low-rank coeftab structure from the internal bcsc.
Definition: cpucblk_sinit.c:500
cpucblk_sfillin
void cpucblk_sfillin(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk)
Initialize the coeftab structure from the internal bcsc.
Definition: cpucblk_sinit.c:604
pastix_bcsc_s::Uvalues
void * Uvalues
Definition: bcsc.h:46
PastixSymmetric
@ PastixSymmetric
Definition: api.h:436