PaStiX Handbook 6.4.0
Loading...
Searching...
No Matches
starpu_cpotrf.c
Go to the documentation of this file.
1/**
2 *
3 * @file starpu_cpotrf.c
4 *
5 * PaStiX cpotrf 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/2mk6rsew/0/solverstack/pastix/sopalin/starpu/starpu_zpotrf.c, normal z -> c, Tue Feb 25 14:35:25 2025
15 *
16 * @addtogroup starpu_potrf
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 potrfsp 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 *******************************************************************************/
44void
45starpu_task_cpotrfsp( sopalin_data_t *sopalin_data,
46 SolverCblk *cblk,
47 int prio )
48{
49 SolverBlok *lblk, *blok;
51
52 if ( cblk->cblktype & CBLK_TASKS_2D ) {
53 starpu_task_blok_cpotrf( 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_cpotrfsp( 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 *******************************************************************************/
99void
100starpu_task_potrf_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 Cholesky factorization with 1D kernels.
134 *
135 * The function performs the Cholesky factorization of a sparse symmetric
136 * positive definite (or Hermitian positive definite in the complex case) matrix
137 * A.
138 * The factorization has the form
139 *
140 * \f[ A = L\times L^H \f]
141 *
142 * where L is a sparse lower triangular matrix.
143 *
144 *******************************************************************************
145 *
146 * @param[inout] sopalin_data
147 * Solver matrix information structure that will guide the algorithm.
148 *
149 * @param[inout] desc
150 * StarPU descriptor of the sparse matrix.
151 *
152 ******************************************************************************/
153void
154starpu_cpotrf_sp1dplus_rl( sopalin_data_t *sopalin_data,
156{
157 const SolverMatrix *solvmtx = sopalin_data->solvmtx;
158 SolverCblk *cblk, *fcblk;
159 SolverBlok *blok, *lblk;
160 pastix_int_t k, m, cblknbr, cblk_n, prio;
161
162 cblknbr = solvmtx->cblknbr;
163 cblk = solvmtx->cblktab;
164 for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
165
166 if ( cblk->cblktype & CBLK_IN_SCHUR ) {
167 break;
168 }
169
170 prio = cblknbr - k;
171
172 /* If this is a fanin, let's submit the send */
173 if ( cblk->cblktype & CBLK_FANIN ) {
174 starpu_task_cadd_1dp_fanin( sopalin_data, PastixLCoef, cblk, prio );
176 continue;
177 }
178
179 /* If this is a recv, let's locally sum the accumulation received */
180 if ( cblk->cblktype & CBLK_RECV ) {
181 starpu_task_cadd_1dp_recv( sopalin_data, PastixLCoef, cblk, prio );
183 continue;
184 }
185
186 starpu_task_cblk_cpotrfsp( sopalin_data, cblk, prio );
187
188 blok = cblk->fblokptr + 1; /* this diagonal block */
189 lblk = cblk[1].fblokptr; /* the next diagonal block */
190
191 /* if there are off-diagonal supernodes in the column */
192 for ( m = 0; blok < lblk; blok++, m++ ) {
193 fcblk = (solvmtx->cblktab + blok->fcblknm);
194 cblk_n = fcblk - solvmtx->cblktab;
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 Cholesky factorization with 1D kernels.
208 *
209 * The function performs the Cholesky factorization of a sparse symmetric
210 * positive definite (or Hermitian positive definite in the complex case) matrix
211 * A.
212 * The factorization has the form
213 *
214 * \f[ A = L\times L^H \f]
215 *
216 * where L is a sparse lower triangular matrix.
217 *
218 *******************************************************************************
219 *
220 * @param[inout] sopalin_data
221 * Solver matrix information structure that will guide the algorithm.
222 *
223 * @param[inout] desc
224 * StarPU descriptor of the sparse matrix.
225 *
226 ******************************************************************************/
227void
228starpu_cpotrf_sp1dplus_ll( sopalin_data_t *sopalin_data,
230{
231 const SolverMatrix *solvmtx = sopalin_data->solvmtx;
232 SolverCblk *cblk, *fcblk;
233 SolverBlok *blok;
234 pastix_int_t k, m, cblknbr, prio;
235
236 cblknbr = solvmtx->cblknbr;
237 fcblk = solvmtx->cblktab;
238 for ( k = 0; k < solvmtx->cblknbr; k++, fcblk++ ) {
239
240 prio = cblknbr - k;
241
242 for ( m = fcblk[0].brownum; m < fcblk[1].brownum; m++ ) {
243 blok = solvmtx->bloktab + solvmtx->browtab[m];
244 cblk = solvmtx->cblktab + blok->lcblknm;
245
246 if ( cblk->cblktype & CBLK_IN_SCHUR ) {
247 break;
248 }
249 assert( !( cblk->cblktype & CBLK_FANIN ) );
250
251 /* If this is a recv, let's locally sum the accumulation received */
252 if ( cblk->cblktype & CBLK_RECV ) {
253 starpu_task_cadd_1dp_recv( sopalin_data, PastixLCoef, cblk, prio );
255 continue;
256 }
257
259 cblk, blok, fcblk, prio );
260 }
261
262 if ( fcblk->cblktype & ( CBLK_IN_SCHUR | CBLK_RECV ) ) {
263 continue;
264 }
265
266 /* If this is a fanin, let's submit the send */
267 if ( fcblk->cblktype & CBLK_FANIN ) {
268 starpu_task_cadd_1dp_fanin( sopalin_data, PastixLCoef, fcblk, prio );
270 continue;
271 }
272
273 starpu_task_cblk_cpotrfsp( sopalin_data, fcblk, prio );
274 }
275
276 cblk = solvmtx->cblktab;
277 for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
278 if ( !(cblk->cblktype & (CBLK_FANIN|CBLK_RECV)) ) {
280 }
281 }
282 (void)desc;
283}
284
285/**
286 *******************************************************************************
287 *
288 * @brief Perform a sparse Cholesky factorization with 1D and 2D kernels.
289 *
290 * The function performs the Cholesky factorization of a sparse symmetric
291 * positive definite (or Hermitian positive definite in the complex case) matrix
292 * A.
293 * The factorization has the form
294 *
295 * \f[ A = L\times L^H \f]
296 *
297 * where L is a sparse lower triangular matrix.
298 *
299 *******************************************************************************
300 *
301 * @param[inout] sopalin_data
302 * Solver matrix information structure that will guide the algorithm.
303 *
304 * @param[inout] desc
305 * StarPU descriptor of the sparse matrix.
306 *
307 ******************************************************************************/
308void
309starpu_cpotrf_sp2d_rl( sopalin_data_t *sopalin_data,
311{
312 const SolverMatrix *solvmtx = sopalin_data->solvmtx;
313 SolverCblk *cblk, *fcblk;
314 SolverBlok *blok, *lblk;
315 pastix_int_t k, m, cblknbr, cblk_n, prio;
316
317 cblknbr = solvmtx->cblknbr;
318
319 /* Let's submit all 1D tasks first */
320 cblk = solvmtx->cblktab;
321 for ( k = 0; k <= solvmtx->cblkmax1d; k++, cblk++ ) {
322
323 if ( cblk->cblktype & CBLK_IN_SCHUR ) {
324 break;
325 }
326
327 if ( cblk->cblktype & CBLK_TASKS_2D ) {
328 continue;
329 }
330
331 prio = cblknbr - k;
332
333 /* If this is a fanin, let's submit the send */
334 if ( cblk->cblktype & CBLK_FANIN ) {
335 starpu_task_cadd_1dp_fanin( sopalin_data, PastixLCoef, cblk, prio );
337 continue;
338 }
339
340 /* If this is a recv, let's locally sum the accumulation received */
341 if ( cblk->cblktype & CBLK_RECV ) {
342 starpu_task_cadd_1dp_recv( sopalin_data, PastixLCoef, cblk, prio );
344 continue;
345 }
346
347 starpu_task_cpotrfsp( sopalin_data, cblk, prio );
348
349 blok = cblk->fblokptr + 1;
350 lblk = cblk[1].fblokptr; /* the next diagonal block */
351
352 for ( m = 0; blok < lblk; blok++, m++ ) {
353 fcblk = ( solvmtx->cblktab + blok->fcblknm );
354 cblk_n = fcblk - solvmtx->cblktab;
355
356 starpu_task_potrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
357 cblknbr - pastix_imin( k + m, cblk_n ) );
358 }
360 }
361
362 /* Let's submit all 2D tasks */
363 cblk = solvmtx->cblktab + solvmtx->cblkmin2d;
364 for ( k = solvmtx->cblkmin2d; k < solvmtx->cblknbr; k++, cblk++ ) {
365
366 if ( cblk->cblktype & CBLK_IN_SCHUR ) {
367 continue;
368 }
369
370 if ( ! ( cblk->cblktype & CBLK_TASKS_2D ) ) {
371 continue;
372 }
373
374 prio = cblknbr - k;
375
376 /* If this is a fanin, let's submit the send */
377 if ( cblk->cblktype & CBLK_FANIN ) {
378 starpu_task_cadd_2d_fanin( sopalin_data, PastixLCoef, cblk, prio );
380 continue;
381 }
382
383 /* If this is a recv, let's locally sum the accumulation received */
384 if ( cblk->cblktype & CBLK_RECV ) {
385 starpu_task_cadd_2d_recv( sopalin_data, PastixLCoef, cblk, prio );
387 continue;
388 }
389
390 starpu_task_cpotrfsp( sopalin_data, cblk, prio );
391
392 blok = cblk->fblokptr + 1;
393 lblk = cblk[1].fblokptr; /* the next diagonal block */
394
395 for ( m = 0; blok < lblk; blok++, m++ ) {
396 fcblk = ( solvmtx->cblktab + blok->fcblknm );
397 cblk_n = blok->fcblknm;
398
399 starpu_task_potrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
400 cblknbr - pastix_imin( k + m, cblk_n ) );
401
402 /* Skip A blocks facing the same cblk */
403 while ( ( blok < lblk ) &&
404 ( blok[0].fcblknm == blok[1].fcblknm ) &&
405 ( blok[0].lcblknm == blok[1].lcblknm ) )
406 {
407 blok++;
408 }
409 }
411 }
412
413 (void)desc;
414}
415
416/**
417 *******************************************************************************
418 *
419 * @brief Perform a sparse Cholesky factorization with 1D and 2D kernels.
420 *
421 * The function performs the Cholesky factorization of a sparse symmetric
422 * positive definite (or Hermitian positive definite in the complex case) matrix
423 * A.
424 * The factorization has the form
425 *
426 * \f[ A = L\times L^H \f]
427 *
428 * where L is a sparse lower triangular matrix.
429 *
430 *******************************************************************************
431 *
432 * @param[inout] sopalin_data
433 * Solver matrix information structure that will guide the algorithm.
434 *
435 * @param[inout] desc
436 * StarPU descriptor of the sparse matrix.
437 *
438 ******************************************************************************/
439void
440starpu_cpotrf_sp2d_ll( sopalin_data_t *sopalin_data,
442{
443 const SolverMatrix *solvmtx = sopalin_data->solvmtx;
444 SolverCblk *cblk, *fcblk;
445 SolverBlok *blok = NULL;
446 SolverBlok *blok_prev;
447 pastix_int_t k, m, cblknbr, prio;
448
449 cblknbr = solvmtx->cblknbr;
450 fcblk = solvmtx->cblktab;
451 for ( k = 0; k < cblknbr; k++, fcblk++ ) {
452
453 prio = cblknbr - k;
454
455 for ( m = fcblk[0].brownum; m < fcblk[1].brownum; m++ ) {
456 blok_prev = blok;
457 blok = solvmtx->bloktab + solvmtx->browtab[m];
458 cblk = solvmtx->cblktab + blok->lcblknm;
459
460 if ( cblk->cblktype & CBLK_IN_SCHUR ) {
461 continue;
462 }
463 assert( !(cblk->cblktype & CBLK_FANIN ) );
464
465 if( ( cblk->cblktype & CBLK_TASKS_2D ) &&
466 ( blok_prev != NULL ) &&
467 ( blok_prev->fcblknm == blok->fcblknm ) &&
468 ( blok_prev->lcblknm == blok->lcblknm ) )
469 {
470 continue;
471 }
472
473 if ( cblk->cblktype & CBLK_RECV ) {
474 starpu_task_cadd_recv( sopalin_data, PastixLCoef, cblk, prio );
476 continue;
477 }
478 starpu_task_potrf_cgemmsp( sopalin_data, cblk, blok, fcblk,
479 prio );
480 }
481
482 if ( fcblk->cblktype & ( CBLK_IN_SCHUR | CBLK_RECV ) ) {
483 continue;
484 }
485
486 if ( fcblk->cblktype & CBLK_FANIN ) {
487 starpu_task_cadd_fanin( sopalin_data, PastixLCoef, fcblk, prio );
489 continue;
490 }
491
492 starpu_task_cpotrfsp( sopalin_data, fcblk, cblknbr - k );
493 }
494
495 cblk = solvmtx->cblktab;
496 for ( k = 0; k < solvmtx->cblknbr; k++, cblk++ ) {
497 if ( !(cblk->cblktype & (CBLK_FANIN|CBLK_RECV)) ) {
499 }
500 }
501
502 (void)desc;
503}
504
505/**
506 *******************************************************************************
507 *
508 * @brief Perform a sparse Cholesky factorization using StarPU runtime.
509 *
510 * The function performs the Cholesky factorization of a sparse symmetric
511 * positive definite (or Hermitian positive definite in the complex case) matrix
512 * A.
513 * The factorization has the form
514 *
515 * \f[ A = L\times L^H \f]
516 *
517 * where L is a sparse lower triangular matrix.
518 *
519 * The algorithm is automatically chosen between the 1D and 2D version based on
520 * the API parameter IPARM_TASKS2D_LEVEL. If IPARM_TASKS2D_LEVEL != 0
521 * the 2D scheme is applied, the 1D otherwise.
522 *
523 *******************************************************************************
524 *
525 * @param[inout] pastix_data
526 * The pastix_data structure that describes the solver instance.
527 *
528 * @param[inout] sopalin_data
529 * Solver matrix information structure that will guide the algorithm.
530 *
531 ******************************************************************************/
532void
534 sopalin_data_t *sopalin_data )
535{
536 starpu_sparse_matrix_desc_t *sdesc = sopalin_data->solvmtx->starpu_desc;
537 float sub = 0.;
538 float com = 0.;
539
540 /*
541 * Start StarPU if not already started
542 */
543 if (pastix_data->starpu == NULL) {
544 int argc = 0;
545 pastix_starpu_init( pastix_data, &argc, NULL, NULL );
546 }
547
548 if ( sdesc == NULL ) {
549 /* Create the matrix descriptor */
550 starpu_sparse_matrix_init( sopalin_data->solvmtx,
552 pastix_data->inter_node_procnbr,
553 pastix_data->inter_node_procnum,
554 PastixComplex32 );
555 sdesc = sopalin_data->solvmtx->starpu_desc;
556 }
557
558 starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
559#if defined(STARPU_USE_FXT)
560 if (pastix_data->iparm[IPARM_TRACE] & PastixTraceNumfact) {
561 starpu_fxt_start_profiling();
562 }
563#endif
564#if defined(PASTIX_STARPU_STATS)
565 clockStart( sub );
566#else
567 starpu_resume();
568#endif
569 /*
570 * Select 1D or 2D algorithm based on 2d tasks level
571 */
572 if ( pastix_data->iparm[IPARM_TASKS2D_LEVEL] != 0 )
573 {
574 if ( pastix_data->iparm[IPARM_FACTO_LOOK_SIDE] == PastixFactLeftLooking ) {
575 starpu_cpotrf_sp2d_ll( sopalin_data, sdesc );
576 }
577 else {
578 starpu_cpotrf_sp2d_rl( sopalin_data, sdesc );
579 }
580 }
581 else
582 {
583 if ( pastix_data->iparm[IPARM_FACTO_LOOK_SIDE] == PastixFactLeftLooking ) {
584 starpu_cpotrf_sp1dplus_ll( sopalin_data, sdesc );
585 }
586 else {
587 starpu_cpotrf_sp1dplus_rl( sopalin_data, sdesc );
588 }
589 }
590
592#if defined(PASTIX_STARPU_STATS)
593 clockStop( sub );
594 clockStart( com );
595 starpu_resume();
596#endif
597 starpu_task_wait_for_all();
598#if defined(PASTIX_WITH_MPI)
599 starpu_mpi_wait_for_all( pastix_data->pastix_comm );
600 starpu_mpi_barrier( pastix_data->inter_node_comm );
601#endif
602 starpu_pause();
603#if defined(STARPU_USE_FXT)
604 if (pastix_data->iparm[IPARM_TRACE] & PastixTraceNumfact) {
605 starpu_fxt_stop_profiling();
606 }
607#endif
608 starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
609#if defined(PASTIX_STARPU_STATS)
610 clockStop( com );
611 print_stats( sub, com, pastix_data->solvmatr );
612#endif
613
614 (void)com;
615 (void)sub;
616 return;
617}
618
619/**
620 *@}
621 */
BEGIN_C_DECLS typedef int pastix_int_t
Definition datatypes.h:51
#define PastixHermitian
Definition api.h:460
@ 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_cpotrf(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_cblk_cpotrfsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
TODO.
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_cpotrf_sp2d_rl(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse Cholesky factorization with 1D and 2D kernels.
void starpu_cpotrf_sp1dplus_rl(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse Cholesky factorization with 1D kernels.
void starpu_cpotrf_sp2d_ll(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse Cholesky factorization with 1D and 2D kernels.
void starpu_task_potrf_cgemmsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, const SolverBlok *blokB, SolverCblk *fcblk, int prio)
Submits starpu cgemmsp cblk or blok task.
void starpu_cpotrf_sp1dplus_ll(sopalin_data_t *sopalin_data, starpu_sparse_matrix_desc_t *desc)
Perform a sparse Cholesky factorization with 1D kernels.
void starpu_task_cpotrfsp(sopalin_data_t *sopalin_data, SolverCblk *cblk, int prio)
Submits starpu potrfsp cblk or blok task.
void starpu_cpotrf(pastix_data_t *pastix_data, sopalin_data_t *sopalin_data)
Perform a sparse Cholesky factorization using StarPU runtime.
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