PaStiX Handbook  6.4.0
starpu_cpxtrf.c
Go to the documentation of this file.
1 /**
2  *
3  * @file starpu_cpxtrf.c
4  *
5  * PaStiX cpxtrf StarPU wrapper.
6  *
7  * @copyright 2016-2024 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
8  * Univ. Bordeaux. All rights reserved.
9  *
10  * @version 6.4.0
11  * @author Mathieu Faverge
12  * @author Pierre Ramet
13  * @date 2024-07-05
14  * @generated from /builds/solverstack/pastix/sopalin/starpu/starpu_zpxtrf.c, normal z -> c, Tue Oct 8 14:17:36 2024
15  *
16  * @addtogroup starpu_pxtrf
17  * @{
18  *
19  **/
20 #include "common.h"
21 #include "blend/solver.h"
22 #include "sopalin/sopalin_data.h"
23 #include "pastix_ccores.h"
24 #include "pastix_starpu.h"
25 #include "pastix_cstarpu.h"
26 
27 /**
28  *******************************************************************************
29  *
30  * @brief Submits starpu pxtrfsp cblk or blok task.
31  *
32  *******************************************************************************
33  *
34  * @param[in] sopalin_data
35  * Solver matrix information structure that will guide the algorithm.
36  *
37  * @param[in] cblk
38  * The column block.
39  *
40  * @param[in] prio
41  * The task priority.
42  *
43  *******************************************************************************/
44 void
45 starpu_task_cpxtrfsp( sopalin_data_t *sopalin_data,
46  SolverCblk *cblk,
47  int prio )
48 {
49  SolverBlok *lblk, *blok;
50  pastix_int_t m;
51 
52  if ( cblk->cblktype & CBLK_TASKS_2D ) {
53  starpu_task_blok_cpxtrf( sopalin_data, cblk, prio );
54 
55  lblk = cblk[1].fblokptr;
56  for ( blok = cblk->fblokptr + 1, m = 0; blok < lblk; blok++, m++ ) {
57 
60  cblk, blok, prio );
61 
62  /* Skip blocks facing the same cblk */
63  while ( ( blok < lblk ) &&
64  ( blok[0].fcblknm == blok[1].fcblknm ) &&
65  ( blok[0].lcblknm == blok[1].lcblknm ) )
66  {
67  blok++;
68  }
69  }
70  }
71  else {
72  starpu_task_cblk_cpxtrfsp( sopalin_data, cblk, prio );
73  }
74 }
75 
76 /**
77  *******************************************************************************
78  *
79  * @brief Submits starpu cgemmsp cblk or blok task.
80  *
81  *******************************************************************************
82  *
83  * @param[in] sopalin_data
84  * Solver matrix information structure that will guide the algorithm.
85  *
86  * @param[in] cblk
87  * The column block.
88  *
89  * @param[in] blokB
90  * The block.
91  *
92  * @param[in] fcblk
93  * The facing column block.
94  *
95  * @param[in] prio
96  * The task priority.
97  *
98  *******************************************************************************/
99 void
100 starpu_task_pxtrf_cgemmsp( sopalin_data_t *sopalin_data,
101  SolverCblk *cblk,
102  const SolverBlok *blokB,
103  SolverCblk *fcblk,
104  int prio )
105 {
106  const SolverBlok *blokA, *lblk;
107 
108  if ( cblk->cblktype & CBLK_TASKS_2D ) {
109  lblk = cblk[1].fblokptr;
110  for ( blokA = blokB; blokA < lblk; blokA++ ) {
111 
113  cblk, fcblk, blokA, blokB, prio );
114 
115  /* Skip B blocks facing the same cblk */
116  while ( ( blokA < lblk ) &&
117  ( blokA[0].fcblknm == blokA[1].fcblknm ) &&
118  ( blokA[0].lcblknm == blokA[1].lcblknm ) )
119  {
120  blokA++;
121  }
122  }
123  }
124  else {
126  cblk, blokB, fcblk, prio );
127  }
128 }
129 
130 /**
131  *******************************************************************************
132  *
133  * @brief Perform a sparse LL^t factorization with 1D kernels.
134  *
135  * The function performs the LL^t factorization of a sparse symmetric complex
136  * matrix A.
137  * The factorization has the form
138  *
139  * \f[ A = L\times L^t \f]
140  *
141  * where L is a sparse lower triangular matrix.
142  *
143  *******************************************************************************
144  *
145  * @param[inout] sopalin_data
146  * Solver matrix information structure that will guide the algorithm.
147  *
148  * @param[inout] desc
149  * StarPU descriptor of the sparse matrix.
150  *
151  ******************************************************************************/
152 void
153 starpu_cpxtrf_sp1dplus_rl( sopalin_data_t *sopalin_data,
155 {
156  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
157  SolverCblk *cblk, *fcblk;
158  SolverBlok *blok, *lblk;
159  pastix_int_t k, m, cblknbr, cblk_n, prio;
160 
161  cblknbr = solvmtx->cblknbr;
162  cblk = solvmtx->cblktab;
163  for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
164 
165  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
166  break;
167  }
168 
169  prio = cblknbr - k;
170 
171  /* If this is a fanin, let's submit the send */
172  if ( cblk->cblktype & CBLK_FANIN ) {
173  starpu_task_cadd_1dp_fanin( sopalin_data, PastixLCoef, cblk, prio );
175  continue;
176  }
177 
178  /* If this is a recv, let's locally sum the accumulation received */
179  if ( cblk->cblktype & CBLK_RECV ) {
180  starpu_task_cadd_1dp_recv( sopalin_data, PastixLCoef, cblk, prio );
182  continue;
183  }
184 
185  starpu_task_cblk_cpxtrfsp( sopalin_data, cblk, prio );
186 
187  blok = cblk->fblokptr + 1; /* this diagonal block */
188  lblk = cblk[1].fblokptr; /* the next diagonal block */
189 
190  /* if there are off-diagonal supernodes in the column */
191  for ( m = 0; blok < lblk; blok++, m++ ) {
192  fcblk = (solvmtx->cblktab + blok->fcblknm);
193  cblk_n = fcblk - solvmtx->cblktab;
194 
196  cblk, blok, fcblk,
197  cblknbr - pastix_imin( k + m, cblk_n ) );
198  }
200  }
201  (void)desc;
202 }
203 
204 /**
205  *******************************************************************************
206  *
207  * @brief Perform a sparse LL^t factorization with 1D kernels.
208  *
209  * The function performs the LL^t factorization of a sparse symmetric complex
210  * matrix A.
211  * The factorization has the form
212  *
213  * \f[ A = L\times L^t \f]
214  *
215  * where L is a sparse lower triangular matrix.
216  *
217  *******************************************************************************
218  *
219  * @param[inout] sopalin_data
220  * Solver matrix information structure that will guide the algorithm.
221  *
222  * @param[inout] desc
223  * StarPU descriptor of the sparse matrix.
224  *
225  ******************************************************************************/
226 void
227 starpu_cpxtrf_sp1dplus_ll( sopalin_data_t *sopalin_data,
229 {
230  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
231  SolverCblk *cblk, *fcblk;
232  SolverBlok *blok;
233  pastix_int_t k, m, cblknbr, prio;
234 
235  cblknbr = solvmtx->cblknbr;
236  fcblk = solvmtx->cblktab;
237  for ( k = 0; k < solvmtx->cblknbr; k++, fcblk++ ) {
238 
239  prio = cblknbr - k;
240 
241  for ( m = fcblk[0].brownum; m < fcblk[1].brownum; m++ ) {
242  blok = solvmtx->bloktab + solvmtx->browtab[m];
243  cblk = solvmtx->cblktab + blok->lcblknm;
244 
245  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
246  break;
247  }
248  assert( !( cblk->cblktype & CBLK_FANIN ) );
249 
250  /* If this is a recv, let's locally sum the accumulation received */
251  if ( cblk->cblktype & CBLK_RECV ) {
252  starpu_task_cadd_1dp_recv( sopalin_data, PastixLCoef, cblk, prio );
254  continue;
255  }
256 
258  cblk, blok, fcblk, prio );
259  }
260 
261  if ( fcblk->cblktype & ( CBLK_IN_SCHUR | CBLK_RECV ) ) {
262  continue;
263  }
264 
265  /* If this is a fanin, let's submit the send */
266  if ( fcblk->cblktype & CBLK_FANIN ) {
267  starpu_task_cadd_1dp_fanin( sopalin_data, PastixLCoef, fcblk, prio );
269  continue;
270  }
271 
272  starpu_task_cblk_cpxtrfsp( sopalin_data, fcblk, prio);
273  }
274 
275  cblk = solvmtx->cblktab;
276  for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
277  if ( !(cblk->cblktype & (CBLK_FANIN|CBLK_RECV)) ) {
279  }
280  }
281  (void)desc;
282 }
283 
284 /**
285  *******************************************************************************
286  *
287  * @brief Perform a sparse LL^t factorization with 1D and 2D kernels.
288  *
289  * The function performs the LL^t factorization of a sparse symmetric complex
290  * matrix A.
291  * The factorization has the form
292  *
293  * \f[ A = L\times L^t \f]
294  *
295  * where L is a sparse lower triangular matrix.
296  *
297  *******************************************************************************
298  *
299  * @param[inout] sopalin_data
300  * Solver matrix information structure that will guide the algorithm.
301  *
302  * @param[inout] desc
303  * StarPU descriptor of the sparse matrix.
304  *
305  ******************************************************************************/
306 void
307 starpu_cpxtrf_sp2d_rl( sopalin_data_t *sopalin_data,
309 {
310  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
311  SolverCblk *cblk, *fcblk;
312  SolverBlok *blok, *lblk;
313  pastix_int_t k, m, cblknbr, cblk_n, prio;
314 
315  cblknbr = solvmtx->cblknbr;
316 
317  /* Let's submit all 1D tasks first */
318  cblk = solvmtx->cblktab;
319  for ( k = 0; k <= solvmtx->cblkmax1d; k++, cblk++ ) {
320 
321  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
322  break;
323  }
324 
325  if ( cblk->cblktype & CBLK_TASKS_2D ) {
326  continue;
327  }
328 
329  prio = cblknbr - k;
330 
331  /* If this is a fanin, let's submit the send */
332  if ( cblk->cblktype & CBLK_FANIN ) {
333  starpu_task_cadd_1dp_fanin( sopalin_data, PastixLCoef, cblk, prio );
335  continue;
336  }
337 
338  /* If this is a recv, let's locally sum the accumulation received */
339  if ( cblk->cblktype & CBLK_RECV ) {
340  starpu_task_cadd_1dp_recv( sopalin_data, PastixLCoef, cblk, prio );
342  continue;
343  }
344 
345  starpu_task_cpxtrfsp( sopalin_data, cblk, prio );
346 
347  blok = cblk->fblokptr + 1; /* this diagonal block */
348  lblk = cblk[1].fblokptr; /* the next diagonal block */
349 
350  /* if there are off-diagonal supernodes in the column */
351  for ( m = 0; blok < lblk; blok++, m++ ) {
352  fcblk = (solvmtx->cblktab + blok->fcblknm);
353  cblk_n = fcblk - solvmtx->cblktab;
354 
355  starpu_task_pxtrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
356  cblknbr - pastix_imin( k + m, cblk_n ) );
357  }
359  }
360 
361  /* Now we submit all 2D tasks */
362  cblk = solvmtx->cblktab + solvmtx->cblkmin2d;
363  for (k=solvmtx->cblkmin2d; k<solvmtx->cblknbr; k++, cblk++ ){
364 
365  if ( !(cblk->cblktype & CBLK_TASKS_2D) ) {
366  continue; /* skip 1D cblk */
367  }
368 
369  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
370  continue;
371  }
372 
373  prio = cblknbr - k;
374 
375  /* If this is a fanin, let's submit the send */
376  if ( cblk->cblktype & CBLK_FANIN ) {
377  starpu_task_cadd_2d_fanin( sopalin_data, PastixLCoef, cblk, prio );
379  continue;
380  }
381 
382  /* If this is a recv, let's locally sum the accumulation received */
383  if ( cblk->cblktype & CBLK_RECV ) {
384  starpu_task_cadd_2d_recv( sopalin_data, PastixLCoef, cblk, prio );
386  continue;
387  }
388 
389  starpu_task_cpxtrfsp( sopalin_data, cblk, prio );
390 
391  lblk = cblk[1].fblokptr; /* the next diagonal block */
392 
393  for ( blok = cblk->fblokptr + 1, m = 0; blok < lblk; blok++, m++ ) {
394  fcblk = ( solvmtx->cblktab + blok->fcblknm );
395  cblk_n = blok->fcblknm;
396 
397 
398  starpu_task_pxtrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
399  cblknbr - pastix_imin( k + m, cblk_n ) );
400 
401  /* Skip A blocks facing the same cblk */
402  while( ( blok < lblk ) &&
403  ( blok[0].fcblknm == blok[1].fcblknm ) &&
404  ( blok[0].lcblknm == blok[1].lcblknm ) )
405  {
406  blok++;
407  }
408  }
410  }
411  (void)desc;
412 }
413 
414 /**
415  *******************************************************************************
416  *
417  * @brief Perform a sparse LL^t factorization with 1D and 2D kernels.
418  *
419  * The function performs the LL^t factorization of a sparse symmetric complex
420  * matrix A.
421  * The factorization has the form
422  *
423  * \f[ A = L\times L^t \f]
424  *
425  * where L is a sparse lower triangular matrix.
426  *
427  *******************************************************************************
428  *
429  * @param[inout] sopalin_data
430  * Solver matrix information structure that will guide the algorithm.
431  *
432  * @param[inout] desc
433  * StarPU descriptor of the sparse matrix.
434  *
435  ******************************************************************************/
436 void
437 starpu_cpxtrf_sp2d_ll( sopalin_data_t *sopalin_data,
439 {
440  const SolverMatrix *solvmtx = sopalin_data->solvmtx;
441  SolverCblk *cblk, *fcblk;
442  SolverBlok *blok = NULL;
443  SolverBlok *blok_prev;
444  pastix_int_t k, m, cblknbr, prio;
445 
446  cblknbr = solvmtx->cblknbr;
447  fcblk = solvmtx->cblktab;
448  for ( k = 0; k < cblknbr; k++, fcblk++ ) {
449 
450  prio = cblknbr - k;
451 
452  for ( m = fcblk[0].brownum; m < fcblk[1].brownum; m++ ) {
453  blok_prev = blok;
454  blok = solvmtx->bloktab + solvmtx->browtab[m];
455  cblk = solvmtx->cblktab + blok->lcblknm;
456 
457  if ( cblk->cblktype & CBLK_IN_SCHUR ) {
458  continue;
459  }
460  assert( !(cblk->cblktype & CBLK_FANIN ) );
461 
462  if( ( cblk->cblktype & CBLK_TASKS_2D ) &&
463  ( blok_prev != NULL ) &&
464  ( blok_prev->fcblknm == blok->fcblknm ) &&
465  ( blok_prev->lcblknm == blok->lcblknm ) )
466  {
467  continue;
468  }
469 
470  if ( cblk->cblktype & CBLK_RECV ) {
471  starpu_task_cadd_recv( sopalin_data, PastixLCoef, cblk, prio );
473  continue;
474  }
475 
476  starpu_task_pxtrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
477  cblknbr - k );
478  }
479 
480  if ( fcblk->cblktype & ( CBLK_IN_SCHUR | CBLK_RECV ) ) {
481  continue;
482  }
483 
484  if ( fcblk->cblktype & CBLK_FANIN ) {
485  starpu_task_cadd_fanin( sopalin_data, PastixLCoef, fcblk, prio );
487  continue;
488  }
489 
490  starpu_task_cpxtrfsp( sopalin_data, fcblk, cblknbr - k );
491  }
492 
493  cblk = solvmtx->cblktab;
494  for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
495  if ( !(cblk->cblktype & (CBLK_FANIN|CBLK_RECV)) ) {
497  }
498  }
499 
500  (void)desc;
501 }
502 
503 /**
504  *******************************************************************************
505  *
506  * @brief Perform a sparse LL^t factorization using StarPU runtime.
507  *
508  * The function performs the LL^t factorization of a sparse symmetric complex
509  * matrix A.
510  * The factorization has the form
511  *
512  * \f[ A = L\times L^t \f]
513  *
514  * where L is a sparse lower triangular matrix.
515  *
516  * The algorithm is automatically chosen between the 1D and 2D version based on
517  * the API parameter IPARM_TASKS2D_LEVEL. If IPARM_TASKS2D_LEVEL != 0
518  * the 2D scheme is applied, the 1D otherwise.
519  *
520  *******************************************************************************
521  *
522  * @param[inout] pastix_data
523  * The pastix_data structure that describes the solver instance.
524  *
525  * @param[inout] sopalin_data
526  * Solver matrix information structure that will guide the algorithm.
527  *
528  ******************************************************************************/
529 void
531  sopalin_data_t *sopalin_data )
532 {
533  starpu_sparse_matrix_desc_t *sdesc = sopalin_data->solvmtx->starpu_desc;
534  float sub = 0.;
535  float com = 0.;
536 
537  /*
538  * Start StarPU if not already started
539  */
540  if (pastix_data->starpu == NULL) {
541  int argc = 0;
542  pastix_starpu_init( pastix_data, &argc, NULL, NULL );
543  }
544 
545  if ( sdesc == NULL ) {
546  /* Create the matrix descriptor */
547  starpu_sparse_matrix_init( sopalin_data->solvmtx,
549  pastix_data->inter_node_procnbr,
550  pastix_data->inter_node_procnum,
551  PastixComplex32 );
552  sdesc = sopalin_data->solvmtx->starpu_desc;
553  }
554 
555  starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
556 #if defined(STARPU_USE_FXT)
557  if (pastix_data->iparm[IPARM_TRACE] & PastixTraceNumfact) {
558  starpu_fxt_start_profiling();
559  }
560 #endif
561 #if defined(PASTIX_STARPU_STATS)
562  clockStart( sub );
563 #else
564  starpu_resume();
565 #endif
566  /*
567  * Select 1D or 2D algorithm based on 2d tasks level
568  */
569  if ( pastix_data->iparm[IPARM_TASKS2D_LEVEL] != 0 )
570  {
571  if ( pastix_data->iparm[IPARM_FACTO_LOOK_SIDE] == PastixFactLeftLooking ) {
572  starpu_cpxtrf_sp2d_ll( sopalin_data, sdesc );
573  }
574  else {
575  starpu_cpxtrf_sp2d_rl( sopalin_data, sdesc );
576  }
577  }
578  else
579  {
580  if ( pastix_data->iparm[IPARM_FACTO_LOOK_SIDE] == PastixFactLeftLooking ) {
581  starpu_cpxtrf_sp1dplus_ll( sopalin_data, sdesc );
582  }
583  else {
584  starpu_cpxtrf_sp1dplus_rl( sopalin_data, sdesc );
585  }
586  }
587 
589 #if defined(PASTIX_STARPU_STATS)
590  clockStop( sub );
591  clockStart( com );
592  starpu_resume();
593 #endif
594  starpu_task_wait_for_all();
595 #if defined(PASTIX_WITH_MPI)
596  starpu_mpi_wait_for_all( pastix_data->pastix_comm );
597  starpu_mpi_barrier( pastix_data->inter_node_comm );
598 #endif
599  starpu_pause();
600 #if defined(STARPU_USE_FXT)
601  if (pastix_data->iparm[IPARM_TRACE] & PastixTraceNumfact) {
602  starpu_fxt_stop_profiling();
603  }
604 #endif
605  starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
606 #if defined(PASTIX_STARPU_STATS)
607  clockStop( com );
608  print_stats( sub, com, pastix_data->solvmatr );
609 #endif
610 
611  (void)com;
612  (void)sub;
613  return;
614 }
615 
616 /**
617  *@}
618  */
BEGIN_C_DECLS typedef int pastix_int_t
Definition: datatypes.h:51
#define PastixSymmetric
Definition: api.h:459
@ PastixLCoef
Definition: api.h:478
@ IPARM_TASKS2D_LEVEL
Definition: api.h:90
@ IPARM_FACTO_LOOK_SIDE
Definition: api.h:100
@ IPARM_TRACE
Definition: api.h:44
@ PastixLower
Definition: api.h:467
@ PastixRight
Definition: api.h:496
@ PastixNonUnit
Definition: api.h:487
@ PastixConjTrans
Definition: api.h:447
@ 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_cpxtrf(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
TODO.
void starpu_task_cblk_cpxtrfsp(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 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.
StarPU descriptor stucture for the sparse matrix.
PASTIX_Comm pastix_comm
Definition: pastixdata.h:76
int inter_node_procnum
Definition: pastixdata.h:84
SolverMatrix * solvmatr
Definition: pastixdata.h:103
int inter_node_procnbr
Definition: pastixdata.h:83
void * starpu
Definition: pastixdata.h:88
pastix_int_t * iparm
Definition: pastixdata.h:70
PASTIX_Comm inter_node_comm
Definition: pastixdata.h:78
Main PaStiX data structure.
Definition: pastixdata.h:68
void starpu_task_pxtrf_cgemmsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, const SolverBlok *blokB, SolverCblk *fcblk, int prio)
Submits starpu cgemmsp cblk or blok task.
void starpu_cpxtrf_sp1dplus_ll(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LL^t factorization with 1D kernels.
void starpu_cpxtrf_sp2d_rl(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LL^t factorization with 1D and 2D kernels.
void starpu_cpxtrf_sp2d_ll(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LL^t factorization with 1D and 2D kernels.
void starpu_cpxtrf_sp1dplus_rl(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse LL^t factorization with 1D kernels.
void starpu_cpxtrf(pastix_data_t *pastix_data, sopalin_data_t *sopalin_data)
Perform a sparse LL^t factorization using StarPU runtime.
void starpu_task_cpxtrfsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
Submits starpu pxtrfsp cblk or blok task.
Definition: starpu_cpxtrf.c:45
void starpu_task_cadd_recv(sopalin_data_t *sopalin_data, pastix_coefside_t side, const SolverCblk *cblk, int prio)
Submits starpu zadd task to send the recv cblk.
void starpu_task_cadd_1dp_recv(sopalin_data_t *sopalin_data, pastix_coefside_t side, const SolverCblk *cblk, int prio)
Submits starpu zadd task to receive and add the recv cblk.
void starpu_task_cadd_fanin(sopalin_data_t *sopalin_data, pastix_coefside_t side, const SolverCblk *cblk, int prio)
Submits starpu zadd task to send the fanin cblk.
void starpu_task_cadd_2d_fanin(sopalin_data_t *sopalin_data, pastix_coefside_t side, const SolverCblk *cblk, int prio)
Submits starpu zadd task to send the fanin block.
void starpu_task_cadd_1dp_fanin(sopalin_data_t *sopalin_data, pastix_coefside_t side, const SolverCblk *cblk, int prio)
Submits starpu zadd task to send the fanin cblk.
void starpu_task_cadd_2d_recv(sopalin_data_t *sopalin_data, pastix_coefside_t side, const SolverCblk *cblk, int prio)
Submits starpu zadd task to receive and add the recv block.
pastix_int_t cblkmin2d
Definition: solver.h:219
pastix_int_t brownum
Definition: solver.h:171
pastix_int_t fcblknm
Definition: solver.h:144
pastix_int_t cblknbr
Definition: solver.h:211
SolverBlok *restrict bloktab
Definition: solver.h:229
pastix_int_t cblkmax1d
Definition: solver.h:218
SolverBlok * fblokptr
Definition: solver.h:168
pastix_int_t *restrict browtab
Definition: solver.h:230
pastix_int_t lcblknm
Definition: solver.h:143
SolverCblk *restrict cblktab
Definition: solver.h:228
int8_t cblktype
Definition: solver.h:164
Solver block structure.
Definition: solver.h:141
Solver column block structure.
Definition: solver.h:161
Solver column block structure.
Definition: solver.h:203