Merge branch 'reduction' into 'master'

Reduction

See merge request !478

cmake_modules/local_subs.py

@@ -51,6 +51,7 @@ _extra_blas = [
     ('',                     'sprint',               'dprint',               'cprint',               'zprint'              ),
     ('',                     'sgered',               'dgered',               'cgered',               'zgered'              ),
     ('',                     'sgerst',               'dgerst',               'cgerst',               'zgerst'              ),
+    ('',                     'sipiv_allreduce',      'dipiv_allreduce',      'cipiv_allreduce',      'zipiv_allreduce'     ),
 ]
 
 _extra_BLAS = [ [ x.upper() for x in row ] for row in _extra_blas ]

compute/pzgetrf.c

@@ -16,6 +16,7 @@
  * @author Mathieu Faverge
  * @author Emmanuel Agullo
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
  * @date 2024-03-16
  * @precisions normal z -> s d c
  *
@@ -146,15 +147,13 @@ chameleon_pzgetrf_panel_facto_percol( struct chameleon_pzgetrf_s *ws,
                 ipiv );
         }
 
-        if ( h < minmn ) {
-            /* Reduce globally (between MPI processes) */
-            INSERT_TASK_ipiv_reducek( options, ipiv, k, h );
-        }
+        /* Reduce globally (between MPI processes) */
+        INSERT_TASK_zipiv_allreduce( A, options, ipiv, ws->proc_involved, k, h, tempkn );
     }
 
     /* Flush temporary data used for the pivoting */
     INSERT_TASK_ipiv_to_perm( options, k * A->mb, tempkm, minmn, ipiv, k );
-    RUNTIME_ipiv_flushk( options->sequence, ipiv, k );
+    RUNTIME_ipiv_flushk( options->sequence, ipiv, A->myrank );
 }
 
 /*
@@ -195,17 +194,14 @@ chameleon_pzgetrf_panel_facto_percol_batched( struct chameleon_pzgetrf_s *ws,
         }
         INSERT_TASK_zgetrf_panel_offdiag_batched_flush( options, A, k, clargs, ipiv );
 
-        if ( h < minmn ) {
-            /* Reduce globally (between MPI processes) */
-            INSERT_TASK_ipiv_reducek( options, ipiv, k, h );
-        }
+        INSERT_TASK_zipiv_allreduce( A, options, ipiv, ws->proc_involved, k, h, tempkn );
     }
 
     free( clargs );
 
     /* Flush temporary data used for the pivoting */
     INSERT_TASK_ipiv_to_perm( options, k * A->mb, tempkm, minmn, ipiv, k );
-    RUNTIME_ipiv_flushk( options->sequence, ipiv, k );
+    RUNTIME_ipiv_flushk( options->sequence, ipiv, A->myrank );
 }
 
 static inline void
@@ -218,6 +214,10 @@ chameleon_pzgetrf_panel_facto_blocked( struct chameleon_pzgetrf_s *ws,
     int m, h, b, nbblock;
     int tempkm, tempkn, tempmm, minmn;
 
+    if ( ! ws->involved ) {
+        return;
+    }
+
     tempkm = k == A->mt-1 ? A->m-k*A->mb : A->mb;
     tempkn = k == A->nt-1 ? A->n-k*A->nb : A->nb;
     minmn  = chameleon_min( tempkm, tempkn );
@@ -233,7 +233,7 @@ chameleon_pzgetrf_panel_facto_blocked( struct chameleon_pzgetrf_s *ws,
         int hmax = b == nbblock-1 ? minmn + 1 - b * ws->ib : ws->ib;
 
         for (h=0; h<hmax; h++){
-            int j =  h + b * ws->ib;
+            int j = h + b * ws->ib;
 
             INSERT_TASK_zgetrf_blocked_diag(
                 options,
@@ -250,26 +250,24 @@ chameleon_pzgetrf_panel_facto_blocked( struct chameleon_pzgetrf_s *ws,
                     ipiv );
             }
 
-            if ( (b < (nbblock-1)) && (h == hmax-1) ) {
+            assert( j <= minmn );
+            /* Reduce globally (between MPI processes) */
+            INSERT_TASK_zipiv_allreduce( A, options, ipiv, ws->proc_involved, k, j, tempkn );
+
+            if ( ( b < (nbblock-1) ) && ( h == hmax-1 ) ) {
                 INSERT_TASK_zgetrf_blocked_trsm(
                     options,
-                    ws->ib, tempkn, b * ws->ib + hmax, ws->ib,
+                    ws->ib, tempkn, j+1, ws->ib,
                     Up(k, k),
                     ipiv );
             }
-
-            assert( j<= minmn );
-            if ( j < minmn ) {
-                /* Reduce globally (between MPI processes) */
-                INSERT_TASK_ipiv_reducek( options, ipiv, k, j );
-            }
         }
     }
     RUNTIME_data_flush( options->sequence, Up(k, k) );
 
     /* Flush temporary data used for the pivoting */
     INSERT_TASK_ipiv_to_perm( options, k * A->mb, tempkm, minmn, ipiv, k );
-    RUNTIME_ipiv_flushk( options->sequence, ipiv, k );
+    RUNTIME_ipiv_flushk( options->sequence, ipiv, A->myrank );
 }
 
 /*
@@ -284,8 +282,8 @@ chameleon_pzgetrf_panel_facto_blocked_batched( struct chameleon_pzgetrf_s *ws,
 {
     int m, h, b, nbblock, hmax, j;
     int tempkm, tempkn, tempmm, minmn;
-    void **clargs = malloc( sizeof(char *) * A->p );
-    memset( clargs, 0, sizeof(char *) * A->p );
+    void **clargs = malloc( sizeof(char *) );
+    memset( clargs, 0, sizeof(char *) );
 
     tempkm = k == A->mt-1 ? A->m-k*A->mb : A->mb;
     tempkn = k == A->nt-1 ? A->n-k*A->nb : A->nb;
@@ -306,10 +304,7 @@ chameleon_pzgetrf_panel_facto_blocked_batched( struct chameleon_pzgetrf_s *ws,
         for ( h = 0; h < hmax; h++ ) {
             j =  h + b * ws->ib;
 
-            INSERT_TASK_zgetrf_panel_blocked_batched( options, tempkm, tempkn, j, k * A->mb, (void *)ws,
-                                                      A(k, k), Up(k, k), clargs, ipiv );
-
-            for ( m = k + 1; m < A->mt; m++ ) {
+            for ( m = k; m < A->mt; m++ ) {
                 tempmm = (m == (A->mt - 1)) ? A->m - m * A->mb : A->mb;
                 INSERT_TASK_zgetrf_panel_blocked_batched( options, tempmm, tempkn, j, m * A->mb,
                                                           (void *)ws, A(m, k), Up(k, k), clargs, ipiv );
@@ -317,6 +312,10 @@ chameleon_pzgetrf_panel_facto_blocked_batched( struct chameleon_pzgetrf_s *ws,
             INSERT_TASK_zgetrf_panel_blocked_batched_flush( options, A, k,
                                                             Up(k, k), clargs, ipiv );
 
+            assert( j <= minmn );
+            /* Reduce globally (between MPI processes) */
+            INSERT_TASK_zipiv_allreduce( A, options, ipiv, ws->proc_involved, k, j, tempkn );
+
             if ( (b < (nbblock-1)) && (h == hmax-1) ) {
                 INSERT_TASK_zgetrf_blocked_trsm(
                     options,
@@ -324,12 +323,6 @@ chameleon_pzgetrf_panel_facto_blocked_batched( struct chameleon_pzgetrf_s *ws,
                     Up(k, k),
                     ipiv );
             }
-
-            assert( j <= minmn );
-            if ( j < minmn ) {
-                /* Reduce globally (between MPI processes) */
-                INSERT_TASK_ipiv_reducek( options, ipiv, k, j );
-            }
         }
     }
 
@@ -337,7 +330,7 @@ chameleon_pzgetrf_panel_facto_blocked_batched( struct chameleon_pzgetrf_s *ws,
 
     /* Flush temporary data used for the pivoting */
     INSERT_TASK_ipiv_to_perm( options, k * A->mb, tempkm, minmn, ipiv, k );
-    RUNTIME_ipiv_flushk( options->sequence, ipiv, k );
+    RUNTIME_ipiv_flushk( options->sequence, ipiv, A->myrank );
 }
 
 static inline void
@@ -347,6 +340,26 @@ chameleon_pzgetrf_panel_facto( struct chameleon_pzgetrf_s *ws,
                                int                         k,
                                RUNTIME_option_t           *options )
 {
+#if defined ( CHAMELEON_USE_MPI )
+    int *proc_involved = malloc( sizeof( int ) * chameleon_min( A->p, A->mt - k) );
+    int  b;
+
+    /* 2DBC only */
+    ws->involved = 0;
+    for ( b = k; (b < A->mt) && ((b-k) < A->p); b ++ ) {
+        int rank = chameleon_getrankof_2d( A, b, k );
+        proc_involved[ b-k ] = rank;
+        if ( rank == A->myrank ) {
+            ws->involved = 1;
+        }
+    }
+    ws->proc_involved = proc_involved;
+    if ( ws->involved == 0 ) {
+	free( proc_involved );
+        return;
+    }
+#endif
+
     /* TODO: Should be replaced by a function pointer */
     switch( ws->alg ) {
     case ChamGetrfNoPivPerColumn:
@@ -354,7 +367,7 @@ chameleon_pzgetrf_panel_facto( struct chameleon_pzgetrf_s *ws,
         break;
 
     case ChamGetrfPPivPerColumn:
-        if ( ws->batch_size > 1 ) {
+        if ( ws->batch_size > 0 ) {
             chameleon_pzgetrf_panel_facto_percol_batched( ws, A, ipiv, k, options );
         }
         else {
@@ -363,7 +376,7 @@ chameleon_pzgetrf_panel_facto( struct chameleon_pzgetrf_s *ws,
         break;
 
     case ChamGetrfPPiv:
-        if ( ws->batch_size > 1 ) {
+        if ( ws->batch_size > 0 ) {
             chameleon_pzgetrf_panel_facto_blocked_batched( ws, A, ipiv, k, options );
         }
         else {
@@ -376,6 +389,9 @@ chameleon_pzgetrf_panel_facto( struct chameleon_pzgetrf_s *ws,
     default:
         chameleon_pzgetrf_panel_facto_nopiv( ws, A, ipiv, k, options );
     }
+#if defined ( CHAMELEON_USE_MPI )
+    free( proc_involved );
+#endif
 }
 
 /**
@@ -503,7 +519,9 @@ void chameleon_pzgetrf( struct chameleon_pzgetrf_s *ws,
          * block column k.
          */
         options.forcesub = chameleon_involved_in_panelk_2dbc( A, k );
-        chameleon_pzgetrf_panel_facto( ws, A, IPIV, k, &options );
+        if ( chameleon_involved_in_panelk_2dbc( A, k ) ) {
+            chameleon_pzgetrf_panel_facto( ws, A, IPIV, k, &options );
+        }
         options.forcesub = 0;
 
         for (n = k+1; n < A->nt; n++) {

compute/zgetrf.c

@@ -19,6 +19,8 @@
  * @author Florent Pruvost
  * @author Matthieu Kuhn
  * @author Lionel Eyraud-Dubois
+ * @author Alycia Lisito
+ * @author Xavier Lacoste
  * @date 2024-03-16
  *
  * @precisions normal z -> s d c
@@ -88,15 +90,11 @@ CHAMELEON_zgetrf_WS_Alloc( const CHAM_desc_t *A )
         chameleon_cleanenv( algostr );
     }
 
-    ws->batch_size = chameleon_getenv_get_value_int( "CHAMELEON_GETRF_BATCH_SIZE", 1 );
+    ws->batch_size = chameleon_getenv_get_value_int( "CHAMELEON_GETRF_BATCH_SIZE", 0 );
     if ( ws->batch_size > CHAMELEON_BATCH_SIZE ) {
         chameleon_warning( "CHAMELEON_BATCH_SIZE", "CHAMELEON_GETRF_BATCH_SIZE must be smaller than CHAMELEON_BATCH_SIZE, please recompile with the right CHAMELEON_BATCH_SIZE, or reduce the CHAMELEON_GETRF_BATCH_SIZE value\n" );
         ws->batch_size = CHAMELEON_BATCH_SIZE;
     }
-    if ( (ws->batch_size > 1) && (CHAMELEON_Comm_rank() > 1) ) {
-        chameleon_warning( "CHAMELEON_BATCH_SIZE", "CHAMELEON_GETRF_BATCH_SIZE is unavailable in distributed, value forced to 1\n" );
-        ws->batch_size = 1;
-    }
 
     /* Allocation of U for permutation of the panels */
     if ( ws->alg == ChamGetrfNoPivPerColumn ) {
@@ -300,7 +298,7 @@ CHAMELEON_zgetrf( int M, int N, CHAMELEON_Complex64_t *A, int LDA, int *IPIV )
     if ( ( ws->alg == ChamGetrfPPivPerColumn ) ||
          ( ws->alg == ChamGetrfPPiv ) )
     {
-        chameleon_ipiv_destroy( &descIPIV );
+        chameleon_ipiv_destroy( &descIPIV, &descAt );
     }
     CHAMELEON_zgetrf_WS_Free( ws );
     chameleon_ztile2lap_cleanup( chamctxt, &descAl, &descAt );

control/compute_z.h

@@ -48,6 +48,8 @@ struct chameleon_pzgetrf_s {
     int          batch_size; /**< Batch size for the panel    */
     CHAM_desc_t  U;
     CHAM_desc_t  Up;
+    int         *proc_involved;
+    int          involved:1;
 };
 
 /**

control/descriptor.h

@@ -20,6 +20,7 @@
  * @author Raphael Boucherie
  * @author Samuel Thibault
  * @author Lionel Eyraud-Dubois
+ * @author Alycia Lisito
  * @date 2023-08-22
  *
  */
@@ -77,7 +78,7 @@ void         chameleon_desc_destroy  ( CHAM_desc_t *desc );
 int          chameleon_desc_check    ( const CHAM_desc_t *desc );
 
 int chameleon_ipiv_init( CHAM_ipiv_t *ipiv, const CHAM_desc_t *desc, void *data );
-void chameleon_ipiv_destroy( CHAM_ipiv_t *ipiv );
+void chameleon_ipiv_destroy( CHAM_ipiv_t *ipiv, const CHAM_desc_t *desc );
 
 /**
  *  Internal function to return address of block (m,n) with m,n = block indices

control/descriptor_ipiv.c

@@ -12,6 +12,8 @@
  * @version 1.3.0
  * @author Mathieu Faverge
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
+ * @author Florent Pruvost
  * @date 2024-03-16
  *
  ***
@@ -73,7 +75,7 @@ int chameleon_ipiv_init( CHAM_ipiv_t *ipiv, const CHAM_desc_t *desc, void *data
     ipiv->mt   = chameleon_ceil( ipiv->m, ipiv->mb );
 
     /* Create runtime specific structure like registering data */
-    RUNTIME_ipiv_create( ipiv );
+    RUNTIME_ipiv_create( ipiv, desc );
 
     return rc;
 }
@@ -91,9 +93,10 @@ int chameleon_ipiv_init( CHAM_ipiv_t *ipiv, const CHAM_desc_t *desc, void *data
  *          The pointer to the ipiv descriptor to destroy.
  *
  */
-void chameleon_ipiv_destroy( CHAM_ipiv_t *ipiv )
+void chameleon_ipiv_destroy( CHAM_ipiv_t       *ipiv,
+                             const CHAM_desc_t *desc )
 {
-    RUNTIME_ipiv_destroy( ipiv );
+    RUNTIME_ipiv_destroy( ipiv, desc );
 }
 
 /**
@@ -162,7 +165,8 @@ int CHAMELEON_Ipiv_Create( CHAM_ipiv_t **ipivptr, const CHAM_desc_t *desc, void
  * @retval CHAMELEON_SUCCESS successful exit
  *
  */
-int CHAMELEON_Ipiv_Destroy(CHAM_ipiv_t **ipivptr)
+int CHAMELEON_Ipiv_Destroy( CHAM_ipiv_t **ipivptr,
+                            const CHAM_desc_t *desc )
 {
     CHAM_context_t *chamctxt;
     CHAM_ipiv_t *ipiv;
@@ -179,7 +183,7 @@ int CHAMELEON_Ipiv_Destroy(CHAM_ipiv_t **ipivptr)
     }
 
     ipiv = *ipivptr;
-    chameleon_ipiv_destroy( ipiv );
+    chameleon_ipiv_destroy( ipiv, desc );
     free(ipiv);
     *ipivptr = NULL;
     return CHAMELEON_SUCCESS;

include/chameleon.h

@@ -18,6 +18,8 @@
  * @author Florent Pruvost
  * @author Philippe Virouleau
  * @author Lionel Eyraud-Dubois
+ * @author Alycia Lisito
+ * @author Loris Lucido
  * @date 2024-03-16
  *
  */
@@ -214,11 +216,16 @@ int  CHAMELEON_Recursive_Desc_Create( CHAM_desc_t **descptr, void *mat, cham_flt
                                       blkaddr_fct_t get_blkaddr, blkldd_fct_t get_blkldd,
                                       blkrankof_fct_t get_rankof, void* get_rankof_arg );
 
-int CHAMELEON_Ipiv_Create ( CHAM_ipiv_t **ipivptr, const CHAM_desc_t *desc, void *data );
-int CHAMELEON_Ipiv_Destroy( CHAM_ipiv_t **ipivptr );
+int CHAMELEON_Ipiv_Create ( CHAM_ipiv_t       **ipivptr,
+                            const CHAM_desc_t  *desc,
+                            void               *data );
+int CHAMELEON_Ipiv_Destroy( CHAM_ipiv_t       **ipivptr,
+                            const CHAM_desc_t  *desc );
 int CHAMELEON_Ipiv_Flush  ( const CHAM_ipiv_t        *ipiv,
                             const RUNTIME_sequence_t *sequence );
-int CHAMELEON_Ipiv_Gather( CHAM_ipiv_t *ipivdesc, int *ipiv, int root );
+int CHAMELEON_Ipiv_Gather( CHAM_ipiv_t *ipivdesc,
+                           int         *ipiv,
+                           int          root );
 void CHAMELEON_Ipiv_Print ( const CHAM_ipiv_t *ipiv );
 
 /**

include/chameleon/runtime.h

@@ -18,6 +18,7 @@
  * @author Samuel Thibault
  * @author Philippe Swartvagher
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
  * @date 2024-03-16
  *
  */
@@ -717,8 +718,10 @@ void RUNTIME_ddisplay_oneprofile (cham_tasktype_t task);
 void RUNTIME_sdisplay_allprofile ();
 void RUNTIME_sdisplay_oneprofile (cham_tasktype_t task);
 
-void RUNTIME_ipiv_create ( CHAM_ipiv_t *ipiv );
-void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv );
+void RUNTIME_ipiv_create ( CHAM_ipiv_t *ipiv,
+                          const CHAM_desc_t *desc );
+void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv,
+                           const CHAM_desc_t *desc );
 void RUNTIME_ipiv_gather ( const RUNTIME_sequence_t *sequence,
                            CHAM_ipiv_t *desc, int *ipiv, int node );
 
@@ -730,18 +733,18 @@ void RUNTIME_perm_flushk( const RUNTIME_sequence_t *sequence,
                           const CHAM_ipiv_t *ipiv, int m );
 
 void *RUNTIME_ipiv_getaddr   ( const CHAM_ipiv_t *ipiv, int m );
-void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h );
-void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h );
+void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int k, int h );
+void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int k, int h );
 void *RUNTIME_perm_getaddr   ( const CHAM_ipiv_t *ipiv, int m );
 void *RUNTIME_invp_getaddr   ( const CHAM_ipiv_t *ipiv, int m );
 
 static inline void *
-RUNTIME_pivot_getaddr( CHAM_ipiv_t *ipiv, int m, int h ) {
+RUNTIME_pivot_getaddr( CHAM_ipiv_t *ipiv, int rank, int k, int h ) {
     if ( h%2 == 0 ) {
-        return RUNTIME_nextpiv_getaddr( ipiv, m, -1 );
+        return RUNTIME_nextpiv_getaddr( ipiv, rank, k, h );
     }
     else {
-        return RUNTIME_prevpiv_getaddr( ipiv, m, -1 );
+        return RUNTIME_prevpiv_getaddr( ipiv, rank, k, h );
     }
 }
 

include/chameleon/tasks.h

@@ -16,6 +16,7 @@
  * @author Cedric Augonnet
  * @author Florent Pruvost
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
  * @date 2024-03-16
  *
  */
@@ -165,7 +166,7 @@ void INSERT_TASK_hgemm( const RUNTIME_option_t *options,
 void INSERT_TASK_ipiv_init   ( const RUNTIME_option_t *options,
                                CHAM_ipiv_t *ipiv );
 void INSERT_TASK_ipiv_reducek( const RUNTIME_option_t *options,
-                               CHAM_ipiv_t *ws, int k, int h );
+                               CHAM_ipiv_t *ws, int k, int h, int rank );
 void INSERT_TASK_ipiv_to_perm( const RUNTIME_option_t *options,
                                int m0, int m, int k,
                                const CHAM_ipiv_t *ipivdesc, int ipivk );

include/chameleon/tasks_z.h

@@ -562,4 +562,12 @@ void INSERT_TASK_zgetrf_blocked_trsm( const RUNTIME_option_t *options,
                                       CHAM_desc_t *U, int Um, int Un,
                                       CHAM_ipiv_t *ws );
 
+void INSERT_TASK_zipiv_allreduce( CHAM_desc_t            *A,
+                                  const RUNTIME_option_t *options,
+                                  CHAM_ipiv_t            *ipiv,
+                                  int                    *proc_involved,
+                                  int                     k,
+                                  int                     h,
+                                  int                     n );
+
 #endif /* _chameleon_tasks_z_h_ */

runtime/CMakeLists.txt

@@ -24,6 +24,7 @@
 #  @author Florent Pruvost
 #  @author Philippe Virouleau
 #  @author Matthieu Kuhn
+#  @author Alycia Lisito
 #  @date 2024-03-16
 #
 ###
@@ -73,6 +74,7 @@ set(CODELETS_ZSRC
     codelets/codelet_zhe2ge.c
     codelets/codelet_zherfb.c
     codelets/codelet_zhessq.c
+    codelets/codelet_zipiv_allreduce.c
     codelets/codelet_zlacpy.c
     codelets/codelet_zlange.c
     codelets/codelet_zlanhe.c

runtime/openmp/codelets/codelet_ipiv.c

@@ -28,13 +28,14 @@ void INSERT_TASK_ipiv_init( const RUNTIME_option_t *options,
 }
 
 void INSERT_TASK_ipiv_reducek( const RUNTIME_option_t *options,
-                               CHAM_ipiv_t *ipiv, int k, int h )
+                               CHAM_ipiv_t *ipiv, int k, int h, int rank )
 {
     assert( 0 );
     (void)options;
     (void)ipiv;
     (void)k;
     (void)h;
+    (void)rank;
 }
 
 void INSERT_TASK_ipiv_to_perm( const RUNTIME_option_t *options,

runtime/openmp/codelets/codelet_zipiv_allreduce.c

+/**
+ *
+ * @file openmp/codelet_zipiv_allreduce.c
+ *
+ * @copyright 2012-2024 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ *                      Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon openmp codelets to do the reduction
+ *
+ * @version 1.3.0
+ * @author Alycia Lisito
+ * @date 2024-06-11
+ * @precisions normal z -> c d s
+ *
+ */
+#include "chameleon_openmp.h"
+
+void INSERT_TASK_zipiv_allreduce( CHAM_desc_t            *A,
+                                  const RUNTIME_option_t *options,
+                                  CHAM_ipiv_t            *ipiv,
+                                  int                    *proc_involved,
+                                  int                     k,
+                                  int                     h,
+                                  int                     n )
+{
+    (void)A;
+    (void)options;
+    (void)ipiv;
+    (void)proc_involved;
+    (void)k;
+    (void)h;
+    (void)n;
+}

runtime/openmp/control/runtime_descriptor_ipiv.c

@@ -12,21 +12,27 @@
  * @version 1.3.0
  * @author Mathieu Faverge
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
+ * @author Florent Pruvost
  * @date 2024-03-16
  *
  */
 #include "chameleon_openmp.h"
 
-void RUNTIME_ipiv_create( CHAM_ipiv_t *ipiv )
+void RUNTIME_ipiv_create( CHAM_ipiv_t *ipiv,
+                          const CHAM_desc_t *desc )
 {
     assert( 0 );
     (void)ipiv;
+    (void)desc;
 }
 
-void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv )
+void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv,
+                           const CHAM_desc_t *desc )
 {
     assert( 0 );
     (void)ipiv;
+    (void)desc;
 }
 
 void *RUNTIME_ipiv_getaddr( const CHAM_ipiv_t *ipiv, int m )
@@ -37,19 +43,21 @@ void *RUNTIME_ipiv_getaddr( const CHAM_ipiv_t *ipiv, int m )
     return NULL;
 }
 
-void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h )
+void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int m, int h )
 {
     assert( 0 );
     (void)ipiv;
+    (void)rank;
     (void)m;
     (void)h;
     return NULL;
 }
 
-void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h )
+void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int m, int h )
 {
     assert( 0 );
     (void)ipiv;
+    (void)rank;
     (void)m;
     (void)h;
     return NULL;

runtime/parsec/codelets/codelet_ipiv.c

@@ -28,13 +28,14 @@ void INSERT_TASK_ipiv_init( const RUNTIME_option_t *options,
 }
 
 void INSERT_TASK_ipiv_reducek( const RUNTIME_option_t *options,
-                               CHAM_ipiv_t *ipiv, int k, int h )
+                               CHAM_ipiv_t *ipiv, int k, int h, int rank )
 {
     assert( 0 );
     (void)options;
     (void)ipiv;
     (void)k;
     (void)h;
+    (void)rank;
 }
 
 static inline int

runtime/parsec/codelets/codelet_zipiv_allreduce.c

+/**
+ *
+ * @file parsec/codelet_zipiv_allreduce.c
+ *
+ * @copyright 2012-2024 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ *                      Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon parsec codelets to do the reduction
+ *
+ * @version 1.3.0
+ * @author Alycia Lisito
+ * @date 2024-06-11
+ * @precisions normal z -> c d s
+ *
+ */
+#include "chameleon_parsec.h"
+
+void INSERT_TASK_zipiv_allreduce( CHAM_desc_t            *A,
+                                  const RUNTIME_option_t *options,
+                                  CHAM_ipiv_t            *ipiv,
+                                  int                    *proc_involved,
+                                  int                     k,
+                                  int                     h,
+                                  int                     n )
+{
+    (void)A;
+    (void)options;
+    (void)ipiv;
+    (void)proc_involved;
+    (void)k;
+    (void)h;
+    (void)n;
+}

runtime/parsec/control/runtime_descriptor_ipiv.c

@@ -12,21 +12,27 @@
  * @version 1.3.0
  * @author Mathieu Faverge
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
+ * @author Florent Pruvost
  * @date 2024-03-16
  *
  */
 #include "chameleon_parsec.h"
 
-void RUNTIME_ipiv_create( CHAM_ipiv_t *ipiv )
+void RUNTIME_ipiv_create( CHAM_ipiv_t *ipiv,
+                          const CHAM_desc_t *desc )
 {
     assert( 0 );
     (void)ipiv;
+    (void)desc;
 }
 
-void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv )
+void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv,
+                           const CHAM_desc_t *desc )
 {
     assert( 0 );
     (void)ipiv;
+    (void)desc;
 }
 
 void *RUNTIME_ipiv_getaddr( const CHAM_ipiv_t *ipiv, int m )
@@ -37,19 +43,21 @@ void *RUNTIME_ipiv_getaddr( const CHAM_ipiv_t *ipiv, int m )
     return NULL;
 }
 
-void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h )
+void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int m, int h )
 {
     assert( 0 );
     (void)ipiv;
+    (void)rank;
     (void)m;
     (void)h;
     return NULL;
 }
 
-void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h )
+void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int m, int h )
 {
     assert( 0 );
     (void)ipiv;
+    (void)rank;
     (void)m;
     (void)h;
     return NULL;

runtime/quark/codelets/codelet_ipiv.c

@@ -28,13 +28,14 @@ void INSERT_TASK_ipiv_init( const RUNTIME_option_t *options,
 }
 
 void INSERT_TASK_ipiv_reducek( const RUNTIME_option_t *options,
-                               CHAM_ipiv_t *ipiv, int k, int h )
+                               CHAM_ipiv_t *ipiv, int k, int h, int rank )
 {
     assert( 0 );
     (void)options;
     (void)ipiv;
     (void)k;
     (void)h;
+    (void)rank;
 }
 
 static inline void

runtime/quark/codelets/codelet_zipiv_allreduce.c

+/**
+ *
+ * @file quark/codelet_zipiv_allreduce.c
+ *
+ * @copyright 2012-2024 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ *                      Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief Chameleon quark codelets to do the reduction
+ *
+ * @version 1.3.0
+ * @author Alycia Lisito
+ * @date 2024-06-11
+ * @precisions normal z -> c d s
+ *
+ */
+#include "chameleon_quark.h"
+
+void INSERT_TASK_zipiv_allreduce( CHAM_desc_t            *A,
+                                  const RUNTIME_option_t *options,
+                                  CHAM_ipiv_t            *ipiv,
+                                  int                    *proc_involved,
+                                  int                     k,
+                                  int                     h,
+                                  int                     n )
+{
+    (void)A;
+    (void)options;
+    (void)ipiv;
+    (void)proc_involved;
+    (void)k;
+    (void)h;
+    (void)n;
+}

runtime/quark/control/runtime_descriptor_ipiv.c

@@ -12,21 +12,27 @@
  * @version 1.3.0
  * @author Mathieu Faverge
  * @author Matthieu Kuhn
+ * @author Alycia Lisito
+ * @author Florent Pruvost
  * @date 2024-03-16
  *
  */
 #include "chameleon_quark.h"
 
-void RUNTIME_ipiv_create( CHAM_ipiv_t *ipiv )
+void RUNTIME_ipiv_create( CHAM_ipiv_t *ipiv,
+                          const CHAM_desc_t *desc )
 {
     assert( 0 );
     (void)ipiv;
+    (void)desc;
 }
 
-void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv )
+void RUNTIME_ipiv_destroy( CHAM_ipiv_t *ipiv,
+                           const CHAM_desc_t *desc )
 {
     assert( 0 );
     (void)ipiv;
+    (void)desc;
 }
 
 void *RUNTIME_ipiv_getaddr( const CHAM_ipiv_t *ipiv, int m )
@@ -37,19 +43,21 @@ void *RUNTIME_ipiv_getaddr( const CHAM_ipiv_t *ipiv, int m )
     return NULL;
 }
 
-void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h )
+void *RUNTIME_nextpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int m, int h )
 {
     assert( 0 );
     (void)ipiv;
+    (void)rank;
     (void)m;
     (void)h;
     return NULL;
 }
 
-void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int m, int h )
+void *RUNTIME_prevpiv_getaddr( const CHAM_ipiv_t *ipiv, int rank, int m, int h )
 {
     assert( 0 );
     (void)ipiv;
+    (void)rank;
     (void)m;
     (void)h;
     return NULL;