# Name

HPL_equil Equilibrate U and forward the column panel L.

# Synopsis

`#include "hpl.h"`
`void` `HPL_equil(` `HPL_T_panel *` `PBCST`, `int *` `IFLAG`, `HPL_T_panel *` `PANEL`, `const enum HPL_TRANS` `TRANS`, `const int` `N`, `double *` `U`, `const int` `LDU`, `int *` `IPLEN`, `const int *` `IPMAP`, `const int *` `IPMAPM1`, `int *` `IWORK` `);`

# Description

HPL_equil equilibrates the local pieces of U, so that on exit to this function, pieces of U contained in every process row are of the same size. This phase makes the rolling phase optimal. In addition, this function probes for the column panel L and forwards it when possible.

# Arguments

    PBCST   (local input/output)          HPL_T_panel *
            On entry,  PBCST  points to the data structure containing the
            panel (to be broadcast) information.

    IFLAG   (local input/output)          int *
            On entry, IFLAG  indicates  whether or not  the broadcast has
            already been completed.  If not,  probing will occur, and the
            outcome will be contained in IFLAG on exit.

    PANEL   (local input/output)          HPL_T_panel *
            On entry,  PANEL  points to the data structure containing the
            panel (to be equilibrated) information.

    TRANS   (global input)                const enum HPL_TRANS
            On entry, TRANS specifies whether  U  is stored in transposed
            or non-transposed form.

    N       (local input)                 const int
            On entry, N  specifies the number of rows or columns of  U. N
            must be at least 0.

    U       (local input/output)          double *
            On entry,  U  is an array of dimension (LDU,*) containing the
            local pieces of U in each process row.

    LDU     (local input)                 const int
            On entry, LDU specifies the local leading dimension of U. LDU
            should be at least MAX(1,IPLEN[nprow]) when  U  is stored  in
            non-transposed form, and MAX(1,N) otherwise.

    IPLEN   (global input)                int *
            On entry, IPLEN is an array of dimension NPROW+1.  This array
            is such that IPLEN[i+1] - IPLEN[i] is the number of rows of U
            in process IPMAP[i].

    IPMAP   (global input)                const int *
            On entry, IPMAP is an array of dimension  NPROW.  This  array
            contains  the  logarithmic mapping of the processes. In other
            words, IPMAP[myrow]  is the absolute coordinate of the sorted
            process.

    IPMAPM1 (global input)                const int *
            On entry, IPMAPM1  is an array of dimension NPROW. This array
            contains  the inverse of the logarithmic mapping contained in
            IPMAP: For i in [0.. NPROCS) IPMAPM1[IPMAP[i]] = i.

    IWORK   (workspace)                   int *
            On entry, IWORK is a workarray of dimension NPROW+1.

# See Also

HPL_pdlaswp01N, HPL_pdlaswp01T.