PaStiX Handbook  6.3.2
core_zsytrfsp.c
Go to the documentation of this file.
1 /**
2  *
3  * @file core_zsytrfsp.c
4  *
5  * PaStiX kernel routines for LDL^t factorization.
6  *
7  * @copyright 2011-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 Xavier Lacoste
14  * @author Gregoire Pichon
15  * @author Alycia Lisito
16  * @author Nolan Bredel
17  * @date 2023-12-11
18  * @generated from /builds/solverstack/pastix/kernels/core_zsytrfsp.c, normal z -> z, Wed Dec 13 12:09:16 2023
19  *
20  **/
21 #include "common.h"
22 #include "cblas.h"
23 #include "blend/solver.h"
24 #include "pastix_zcores.h"
25 #include "kernels_trace.h"
26 
27 #include <lapacke.h>
28 
29 #ifndef DOXYGEN_SHOULD_SKIP_THIS
30 #define MAXSIZEOFBLOCKS 64
31 static pastix_complex64_t zone = 1.0;
32 static pastix_complex64_t mzone = -1.0;
33 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
34 
35 /**
36  *******************************************************************************
37  *
38  * @ingroup kernel_blas_lapack_null
39  *
40  * @brief Compute the sequential static pivoting factorization of the symmetric
41  * matrix n-by-n A such that A = L * D * L^t.
42  *
43  *******************************************************************************
44  *
45  * @param[in] n
46  * The number of rows and columns of the matrix A.
47  *
48  * @param[inout] A
49  * The matrix A to factorize with LDL^t factorization. The matrix
50  * is of size lda -by- n.
51  *
52  * @param[in] lda
53  * The leading dimension of the matrix A.
54  *
55  * @param[inout] nbpivots
56  * Pointer to the number of piovting operations made during
57  * factorization. It is updated during this call
58  *
59  * @param[in] criterion
60  * Threshold use for static pivoting. If diagonal value is under this
61  * threshold, its value is replaced by the threshold and the number of
62  * pivots is incremented.
63  *
64  *******************************************************************************/
65 static inline void
67  pastix_complex64_t *A,
68  pastix_int_t lda,
69  pastix_int_t *nbpivots,
70  double criterion )
71 {
72  pastix_int_t k, m;
73  pastix_complex64_t *Akk = A; /* A [k ][k ] */
74  pastix_complex64_t *Amk = A+1; /* A [k+1][k ] */
75  pastix_complex64_t *Akm = A+lda; /* A [k ][k+1] */
76  pastix_complex64_t alpha;
77 
78  m = n-1;
79  for (k=0; k<n; k++, m--){
80  if ( cabs(*Akk) < criterion ) {
81  if ( creal(*Akk) < 0. ) {
82  *Akk = (pastix_complex64_t)(-criterion);
83  }
84  else {
85  *Akk = (pastix_complex64_t)criterion;
86  }
87  (*nbpivots)++;
88  }
89 
90  alpha = 1.0 / (*Akk);
91 
92  /* Transpose the column before scaling */
93  cblas_zcopy( m, Amk, 1, Akm, lda );
94 
95  /* Scale the diagonal to compute L((k+1):n,k) */
96  cblas_zscal(m, CBLAS_SADDR( alpha ), Amk, 1 );
97 
98  alpha = -(*Akk);
99 
100  /* Move to next Akk */
101  Akk += (lda+1);
102 
103  cblas_zsyrk(CblasColMajor, CblasLower, CblasNoTrans,
104  m, 1,
105  CBLAS_SADDR( alpha ), Amk, lda,
106  CBLAS_SADDR( zone ), Akk, lda);
107 
108  /* Move to next Amk */
109  Amk = Akk+1;
110  Akm = Akk+lda;
111  }
112 }
113 
114 /**
115  *******************************************************************************
116  *
117  * @brief Compute the block static pivoting factorization of the symmetric
118  * matrix n-by-n A such that A = L * D * L^t.
119  *
120  *******************************************************************************
121  *
122  * @param[in] n
123  * The number of rows and columns of the matrix A.
124  *
125  * @param[inout] A
126  * The matrix A to factorize with LDL^t factorization. The matrix
127  * is of size lda -by- n.
128  *
129  * @param[in] lda
130  * The leading dimension of the matrix A.
131  *
132  * @param[inout] nbpivots
133  * Pointer to the number of piovting operations made during
134  * factorization. It is updated during this call
135  *
136  * @param[in] criterion
137  * Threshold use for static pivoting. If diagonal value is under this
138  * threshold, its value is replaced by the threshold and the nu,ber of
139  * pivots is incremented.
140  *
141  *******************************************************************************/
142 void
144  pastix_complex64_t *A,
145  pastix_int_t lda,
146  pastix_int_t *nbpivots,
147  double criterion )
148 {
149  pastix_int_t k, blocknbr, blocksize, matrixsize, col;
150  pastix_complex64_t *Akk, *Amk, *Akm, *Amm;
151  pastix_complex64_t alpha;
152 
153  /* diagonal supernode is divided into MAXSIZEOFBLOCK-by-MAXSIZEOFBLOCKS blocks */
154  blocknbr = pastix_iceil( n, MAXSIZEOFBLOCKS );
155 
156  for (k=0; k<blocknbr; k++) {
157 
158  blocksize = pastix_imin(MAXSIZEOFBLOCKS, n-k*MAXSIZEOFBLOCKS);
159  Akk = A+(k*MAXSIZEOFBLOCKS)*(lda+1); /* Lk, k */
160  Amk = Akk + blocksize; /* Lk+1,k */
161  Akm = Akk + blocksize * lda; /* Lk, k+1 */
162  Amm = Amk + blocksize * lda; /* Lk+1,k+1 */
163 
164  /* Factorize the diagonal block Akk*/
165  core_zsytf2sp(blocksize, Akk, lda, nbpivots, criterion);
166 
167  if ((k*MAXSIZEOFBLOCKS+blocksize) < n) {
168 
169  matrixsize = n-(k*MAXSIZEOFBLOCKS+blocksize);
170 
171  /*
172  * Solve the lower rectangle below the diagonal block
173  * L(k+1:n,k) = (L(k,k) D(k,k))^{-1} A(k+1:n,k)
174  */
175  /* 1) Compute A(k+1:n,k) = A(k+1:n,k)L(k,k)^{-T} = D(k,k)L(k+1:n,k) */
176  /* input: L(k,k) in tmp, A(k+1:n,k) in tmp1 */
177  /* output: A(k+1:n,k) in tmp1 */
178  cblas_ztrsm(CblasColMajor,
179  CblasRight, CblasLower,
180  CblasTrans, CblasUnit,
181  matrixsize, blocksize,
182  CBLAS_SADDR(zone), Akk, lda,
183  Amk, lda);
184 
185  /* Compute L(k+1:n,k) = A(k+1:n,k)D(k,k)^{-1} */
186  for(col = 0; col < blocksize; col++) {
187  /* copy L(k+1+col:n,k+col)*D(k+col,k+col) into work(:,col) */
188  cblas_zcopy(matrixsize, Amk + col*lda, 1,
189  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^t 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
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 
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  L = lrL->u;
254  stride = ncols;
255 
256  assert( lrL->rk == -1 );
257  assert( stride == lrL->rkmax );
258  } else {
259  L = (pastix_complex64_t *)dataL;
260  }
261 
262  /*
263  * Factorize diagonal block in L D L^t
264  *
265  * - lower part holds L
266  * - diagonal holds D
267  * - uppert part holds (DL^t)
268  */
269  flops = FLOPS_ZSYTRF( ncols );
270  kernel_trace_start_lvl2( PastixKernelLvl2SYTRF );
271  core_zsytrfsp( ncols, L, stride, &nbpivots, criterion );
272  kernel_trace_stop_lvl2( flops );
273 
274  kernel_trace_stop( cblk->fblokptr->inlast, PastixKernelSYTRF, 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_zsytrfsp1d_gemm - Computes the LDL^t 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  *******************************************************************************/
317  const SolverBlok *blok,
318  SolverCblk *fcblk,
319  const pastix_complex64_t *L,
320  pastix_complex64_t *C,
321  pastix_complex64_t *work )
322 {
323  const SolverBlok *iterblok;
324  const SolverBlok *fblok;
325  const SolverBlok *lblok;
326  const pastix_complex64_t *blokA;
327  const pastix_complex64_t *blokB;
328  const pastix_complex64_t *blokD;
329  pastix_complex64_t *blokC;
330 
331  pastix_int_t M, N, K, lda, ldb, ldc, ldd;
332 
333  /* Get the panel update dimensions */
334  K = cblk_colnbr( cblk );
335  N = blok_rownbr( blok );
336 
337  /* Get info for diagonal, and the B block */
338  blokD = L;
339  blokB = L + blok->coefind;
340  if ( cblk->cblktype & CBLK_LAYOUT_2D ) {
341  ldb = N;
342  ldd = K + 1;
343  }
344  else {
345  ldb = cblk->stride;
346  ldd = cblk->stride + 1;
347  }
348 
349  /*
350  * Add contribution to C in fcblk:
351  * Get the first facing block of the distant panel, and the last block of
352  * the current cblk
353  */
354  fblok = fcblk->fblokptr;
355  lblok = cblk[1].fblokptr;
356 
357  for (iterblok=blok; iterblok<lblok; iterblok++) {
358 
359  /* Find facing blok */
360  while (!is_block_inside_fblock( iterblok, fblok ))
361  {
362  fblok++;
363  assert( fblok < fcblk[1].fblokptr );
364  }
365 
366  /* Get the A block and its dimensions */
367  M = blok_rownbr( iterblok );
368  blokA = L + iterblok->coefind;
369  lda = (cblk->cblktype & CBLK_LAYOUT_2D) ? M : cblk->stride;
370 
371  /* Get the C block */
372  ldc = (fcblk->cblktype & CBLK_LAYOUT_2D) ? blok_rownbr(fblok) : fcblk->stride;
373 
374  blokC = C + fblok->coefind
375  + iterblok->frownum - fblok->frownum
376  + (blok->frownum - fcblk->fcolnum) * ldc;
377 
378  {
379  pastix_int_t ldw;
380  int ret;
381 
382  /* Compute ldw which should never be larger than SOLVE_COEFMAX */
383  ldw = (M+1) * K;
384 
385  pastix_cblk_lock( fcblk );
387  M, N, K,
388  -1.0, blokA, lda,
389  blokB, ldb,
390  1.0, blokC, ldc,
391  blokD, ldd,
392  work, ldw );
393  pastix_cblk_unlock( fcblk );
394  assert(ret == PASTIX_SUCCESS);
395  (void)ret;
396  }
397  }
398 }
399 
400 /**
401  *******************************************************************************
402  *
403  * @brief Compute the LDL^t factorization of one panel.
404  *
405  *******************************************************************************
406  *
407  * @param[in] solvmtx
408  * Solver Matrix structure of the problem
409  *
410  * @param[in] cblk
411  * Pointer to the structure representing the panel to factorize in the
412  * cblktab array. Next column blok must be accessible through cblk[1].
413  *
414  * @param[inout] L
415  * The pointer to the correct representation of lower part of the data.
416  * - coeftab if the block is in full rank. Must be of size cblk.stride -by- cblk.width.
417  * - pastix_lr_block if the block is compressed.
418  *
419  * @param[inout] DLt
420  * The pointer to the correct representation of DLt matrix
421  * (stored in the upper part by default).
422  * - coeftab if the block is in full rank. Must be of size cblk.stride -by- cblk.width.
423  * - pastix_lr_block if the block is compressed.
424  *
425  *******************************************************************************
426  *
427  * @return The number of static pivoting during factorization of the diagonal
428  * block.
429  *
430  *******************************************************************************/
431 int
433  SolverCblk *cblk,
434  void *L,
435  void *DLt )
436 {
437  pastix_int_t nbpivots;
438  nbpivots = cpucblk_zsytrfsp1d_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_zscalo( 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
488  SolverCblk *cblk,
489  pastix_complex64_t *DLt,
490  pastix_complex64_t *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_zalloc_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_zsytrfsp1d_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_zalloc( PastixLCoef, fcblk );
524  }
525 
526  /* Update on L */
527  if ( DLt == NULL ) {
528  core_zsytrfsp1d_gemm( cblk, blok, fcblk,
529  dataL, cblk_getdataL( fcblk ),
530  work );
531  }
532  else {
534  cblk, blok, fcblk,
535  dataL, dataDLt, cblk_getdataL( fcblk ),
536  work, lwork, &(solvmtx->lowrank) );
537  }
538  cpucblk_zrelease_deps( PastixLCoef, solvmtx, cblk, fcblk );
539  }
540 
541  return nbpivots;
542 }
543 
544 /**
545  *******************************************************************************
546  *
547  * @brief Perform the LDL^t factorization of a given panel and submit tasks
548  * for the subsequent updates.
549  *
550  *******************************************************************************
551  *
552  * @param[in] solvmtx
553  * Solver Matrix structure of the problem
554  *
555  * @param[in] cblk
556  * Pointer to the structure representing the panel to factorize in the
557  * cblktab array. Next column blok must be accessible through cblk[1].
558  *
559  *******************************************************************************
560  *
561  * @return The number of static pivoting during factorization of the diagonal
562  * block.
563  *
564  *******************************************************************************/
565 int
567  SolverCblk *cblk )
568 {
569  void *dataL = cblk_getdataL( cblk );
570  SolverBlok *blok, *lblk;
571  pastix_int_t i, nbpivots;
572  pastix_queue_t *queue = solvmtx->computeQueue[ cblk->threadid ];
573 
574  assert( cblk->cblktype & CBLK_TASKS_2D );
575  nbpivots = cpucblk_zsytrfsp1d_panel( solvmtx, cblk, dataL, NULL );
576 
577  blok = cblk->fblokptr + 1; /* this diagonal block */
578  lblk = cblk[1].fblokptr; /* the next diagonal block */
579 
580  /* if there are off-diagonal supernodes in the column */
581  for( i=0; blok < lblk; i++, blok++ )
582  {
583  assert( !((solvmtx->cblktab + blok->fcblknm)->cblktype & CBLK_RECV) );
584  pqueuePush1( queue, - (blok - solvmtx->bloktab) - 1, cblk->priority + i );
585 
586  /* Skip blocks facing the same cblk */
587  while ( ( blok < lblk ) &&
588  ( blok[0].fcblknm == blok[1].fcblknm ) &&
589  ( blok[0].lcblknm == blok[1].lcblknm ) )
590  {
591  blok++;
592  }
593  }
594 
595  return nbpivots;
596 }
597 
598 /**
599  *******************************************************************************
600  *
601  * @brief Apply the updates of the LDL^t factorisation of a given panel.
602  *
603  *******************************************************************************
604  *
605  * @param[in] solvmtx
606  * Solver Matrix structure of the problem
607  *
608  * @param[in] blok
609  * Pointer to the blok where the update start.
610  *
611  * @param[in] work
612  * Temporary memory buffer.
613  *
614  * @param[in] lwork
615  * Temporary workspace dimension.
616  *
617  *******************************************************************************/
618 void
620  SolverBlok *blok,
621  pastix_complex64_t *work )
622 {
623  SolverCblk *cblk = solvmtx->cblktab + blok->lcblknm;
624  SolverCblk *fcbk = solvmtx->cblktab + blok->fcblknm;
625  SolverBlok *lblk = cblk[1].fblokptr; /* the next diagonal block */
626  void *dataL = cblk_getdataL( cblk );
627 
628  if ( fcbk->cblktype & CBLK_FANIN ) {
629  cpucblk_zalloc( PastixLCoef, fcbk );
630  }
631 
632  do
633  {
634  /* Update on L (3 terms) */
635  core_zsytrfsp1d_gemm( cblk, blok, fcbk,
636  dataL, fcbk->lcoeftab,
637  work );
638 
639  cpucblk_zrelease_deps( PastixLCoef, solvmtx, cblk, fcbk );
640  blok++;
641  }
642  while ( ( blok < lblk ) &&
643  ( blok[-1].fcblknm == blok[0].fcblknm ) &&
644  ( blok[-1].lcblknm == blok[0].lcblknm ) );
645 }
static void core_zsytf2sp(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 symmetric matrix n-by-n A such that A = L...
Definition: core_zsytrfsp.c:66
BEGIN_C_DECLS typedef int pastix_int_t
Definition: datatypes.h:51
double pastix_fixdbl_t
Definition: datatypes.h:65
static void pqueuePush1(pastix_queue_t *q, pastix_int_t elt, double key1)
Push an element with a single key.
Definition: queue.h:64
Queue structure.
Definition: queue.h:38
static void kernel_trace_stop(int8_t inlast, pastix_ktype_t ktype, int m, int n, int k, double flops, double starttime)
Stop the trace of a single kernel.
static double kernel_trace_start(pastix_ktype_t ktype)
Start the trace of a single kernel.
Definition: kernels_trace.h:87
@ PastixKernelLvl2SYTRF
Definition: kernels_enums.h:91
@ PastixKernelSYTRF
Definition: kernels_enums.h:52
void core_zsytrfsp(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 symmetric matrix n-by-n A such that A = L * D ...
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
void core_zsytrfsp1d_gemm(const SolverCblk *cblk, const SolverBlok *blok, SolverCblk *fcblk, const pastix_complex64_t *L, pastix_complex64_t *C, pastix_complex64_t *work)
void cpucblk_zsytrfsp1dplus_update(SolverMatrix *solvmtx, SolverBlok *blok, pastix_complex64_t *work)
Apply the updates of the LDL^t factorisation of a given panel.
int cpucblk_zsytrfsp1dplus(SolverMatrix *solvmtx, SolverCblk *cblk)
Perform the LDL^t factorization of a given panel and submit tasks for the subsequent updates.
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
int cpucblk_zsytrfsp1d_panel(SolverMatrix *solvmtx, SolverCblk *cblk, void *L, void *DLt)
Compute the LDL^t factorization of one panel.
void cpucblk_zalloc(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
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.
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.
void cpucblk_zscalo(pastix_trans_t trans, const SolverCblk *cblk, void *dataL, void *dataLD)
Copy the L term with scaling for the two-terms algorithm.
Definition: core_zscalo.c:171
int cpucblk_zsytrfsp1d_sytrf(SolverMatrix *solvmtx, SolverCblk *cblk, void *dataL)
Computes the LDL^t factorization of the diagonal block in a panel.
int cpucblk_zsytrfsp1d(SolverMatrix *solvmtx, SolverCblk *cblk, pastix_complex64_t *DLt, pastix_complex64_t *work, pastix_int_t lwork)
Perform the LDL^t factorization of a given panel and apply all its updates.
void cpucblk_zalloc_lrws(const SolverCblk *cblk, pastix_lrblock_t *lrblok, pastix_complex64_t *ws)
Initialize lrblock structure from a workspace for all blocks of the cblk associated.
Definition: cpucblk_zinit.c:98
The block low-rank structure to hold a matrix in low-rank form.
@ PastixLCoef
Definition: api.h:478
@ 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
@ PASTIX_SUCCESS
Definition: api.h:367
static pastix_int_t blok_rownbr(const SolverBlok *blok)
Compute the number of rows of a block.
Definition: solver.h:390
pastix_lr_t lowrank
Definition: solver.h:230
pastix_int_t priority
Definition: solver.h:177
static pastix_int_t cblk_colnbr(const SolverCblk *cblk)
Compute the number of columns in a column block.
Definition: solver.h:324
pastix_int_t fcblknm
Definition: solver.h:140
static int is_block_inside_fblock(const SolverBlok *blok, const SolverBlok *fblok)
Check if a block is included inside another one.
Definition: solver.h:499
SolverBlok *restrict bloktab
Definition: solver.h:223
pastix_int_t frownum
Definition: solver.h:142
static void * cblk_getdataU(const SolverCblk *cblk)
Get the pointer to the data associated to the upper part of the cblk.
Definition: solver.h:349
pastix_int_t coefind
Definition: solver.h:144
SolverBlok * fblokptr
Definition: solver.h:163
static void * cblk_getdataL(const SolverCblk *cblk)
Get the pointer to the data associated to the lower part of the cblk.
Definition: solver.h:337
pastix_int_t lcblknm
Definition: solver.h:139
int threadid
Definition: solver.h:176
int8_t inlast
Definition: solver.h:146
SolverCblk *restrict cblktab
Definition: solver.h:222
pastix_int_t stride
Definition: solver.h:164
int8_t cblktype
Definition: solver.h:159
pastix_int_t lcolnum
Definition: solver.h:162
void * lcoeftab
Definition: solver.h:171
double diagthreshold
Definition: solver.h:232
volatile int32_t nbpivots
Definition: solver.h:233
pastix_int_t fcolnum
Definition: solver.h:161
Solver block structure.
Definition: solver.h:137
Solver column block structure.
Definition: solver.h:156
Solver column block structure.
Definition: solver.h:200