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