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