Distributed SuperLU data types and function prototypes. More...
Include dependency graph for superlu_zdefs.h:
Go to the source code of this file.
Classes | |
| struct | zScalePermstruct_t |
| struct | zLocalLU_t |
| struct | zLUValSubBuf_t |
| struct | ztrf3Dpartition_t |
| struct | zLUstruct_t |
| struct | pzgsmv_comm_t |
| struct | zSOLVEstruct_t |
| struct | zscuBufs_t |
| struct | zdiagFactBufs_t |
| struct | zxT_struct |
| struct | zlsumBmod_buff_t |
Macros | |
| #define | MAX_LOOKAHEADS 50 |
Typedefs | |
| typedef struct zxT_struct | zxT_struct |
| typedef struct zlsumBmod_buff_t | zlsumBmod_buff_t |
Variables | |
| doublecomplex * | zready_x |
| doublecomplex * | zready_lsum |
Detailed Description
Distributed SuperLU data types and function prototypes.
Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)
All rights reserved.
The source code is distributed under BSD license, see the file License.txt at the top-level directory.
-- Distributed SuperLU routine (version 9.0) -- Lawrence Berkeley National Lab, Univ. of California Berkeley, Georgia Institute of Technology November 1, 2007 April 5, 2015 September 18, 2018 version 6.0 February 8, 2019 version 6.1.1 May 10, 2019 version 7.0.0
Macro Definition Documentation
◆ MAX_LOOKAHEADS
| #define MAX_LOOKAHEADS 50 |
Typedef Documentation
◆ zlsumBmod_buff_t
| typedef struct zlsumBmod_buff_t zlsumBmod_buff_t |
◆ zxT_struct
| typedef struct zxT_struct zxT_struct |
Function Documentation
◆ checkRecvLDiag()
| int_t checkRecvLDiag | ( | int_t | k, |
| commRequests_t * | comReqs, | ||
| gridinfo_t * | grid, | ||
| SCT_t * | SCT | ||
| ) |
◆ checkRecvUDiag()
| int_t checkRecvUDiag | ( | int_t | k, |
| commRequests_t * | comReqs, | ||
| gridinfo_t * | grid, | ||
| SCT_t * | SCT | ||
| ) |
◆ doubleCalloc_dist()
| double * doubleCalloc_dist | ( | int_t | n | ) |
◆ doublecomplexCalloc_dist()
| doublecomplex * doublecomplexCalloc_dist | ( | int_t | n | ) |
Here is the caller graph for this function:
◆ doublecomplexMalloc_dist()
| doublecomplex * doublecomplexMalloc_dist | ( | int_t | n | ) |
Here is the caller graph for this function:
◆ doubleMalloc_dist()
| double * doubleMalloc_dist | ( | int_t | n | ) |
Here is the caller graph for this function:
◆ file_PrintDoublecomplex()
| int file_PrintDoublecomplex | ( | FILE * | fp, |
| char * | name, | ||
| int_t | len, | ||
| doublecomplex * | x | ||
| ) |
◆ file_zPrint_CompRowLoc_Matrix_dist()
| int file_zPrint_CompRowLoc_Matrix_dist | ( | FILE * | fp, |
| SuperMatrix * | A | ||
| ) |
◆ Free_HyP()
| void Free_HyP | ( | HyP_t * | HyP | ) |
◆ freePackLUInfo()
| int freePackLUInfo | ( | packLUInfo_t * | packLUInfo | ) |
◆ getNsupers()
| int getNsupers | ( | int | n, |
| Glu_persist_t * | Glu_persist | ||
| ) |
◆ initPackLUInfo()
| int_t initPackLUInfo | ( | int_t | nsupers, |
| packLUInfo_t * | packLUInfo | ||
| ) |
◆ Local_Zgstrf2()
| void Local_Zgstrf2 | ( | superlu_dist_options_t * | options, |
| int_t | k, | ||
| double | thresh, | ||
| doublecomplex * | BlockUFactor, | ||
| Glu_persist_t * | , | ||
| gridinfo_t * | , | ||
| zLocalLU_t * | , | ||
| SuperLUStat_t * | , | ||
| int * | info, | ||
| SCT_t * | |||
| ) |
Here is the caller graph for this function:
◆ nv_init_wrapper()
| void nv_init_wrapper | ( | MPI_Comm | ) |
◆ PrintDoublecomplex()
| void PrintDoublecomplex | ( | char * | name, |
| int_t | len, | ||
| doublecomplex * | x | ||
| ) |
Here is the caller graph for this function:
◆ pxgstrs_finalize()
| void pxgstrs_finalize | ( | pxgstrs_comm_t * | gstrs_comm | ) |
◆ pzCompRow_loc_to_CompCol_global()
| int pzCompRow_loc_to_CompCol_global | ( | int_t | need_value, |
| SuperMatrix * | A, | ||
| gridinfo_t * | grid, | ||
| SuperMatrix * | GA | ||
| ) |
Gather A from the distributed compressed row format to global A in compressed column format.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzCompute_Diag_Inv()
| void pzCompute_Diag_Inv | ( | int_t | n, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose ======= Compute the inverse of the diagonal blocks of the L and U triangular matrices.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzconvert_flatten_skyline2UROWDATA()
| void pzconvert_flatten_skyline2UROWDATA | ( | superlu_dist_options_t * | options, |
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct, | ||
| SuperLUStat_t * | stat, | ||
| int | n | ||
| ) |
Here is the call graph for this function:
◆ pzconvertU()
| void pzconvertU | ( | superlu_dist_options_t * | , |
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SuperLUStat_t * | , | ||
| int | |||
| ) |
Here is the caller graph for this function:
◆ pzconvertUROWDATA2skyline()
| void pzconvertUROWDATA2skyline | ( | superlu_dist_options_t * | options, |
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct, | ||
| SuperLUStat_t * | stat, | ||
| int | n | ||
| ) |
Here is the call graph for this function:
◆ pzdistribute()
| float pzdistribute | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzdistribute3d_Yang()
| float pzdistribute3d_Yang | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzdistribute_allgrid()
| float pzdistribute_allgrid | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| int * | supernodeMask | ||
| ) |
Here is the call graph for this function:
◆ pzdistribute_allgrid_index_only()
| float pzdistribute_allgrid_index_only | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| int * | supernodeMask | ||
| ) |
Here is the call graph for this function:
◆ pzflatten_LDATA()
| int pzflatten_LDATA | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat | ||
| ) |
Here is the caller graph for this function:
◆ pzGetDiagU()
| void pzGetDiagU | ( | int_t | n, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| doublecomplex * | diagU | ||
| ) |
Purpose
=======
GetDiagU extracts the main diagonal of matrix U of the LU factorization.
Arguments
=========
n (input) int
Dimension of the matrix.
LUstruct (input) zLUstruct_t*
The data structures to store the distributed L and U factors.
see superlu_ddefs.h for its definition.
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
diagU (output) double*, dimension (n)
The main diagonal of matrix U.
On exit, it is available on all processes.
Note
====
The diagonal blocks of the L and U matrices are stored in the L
data structures, and are on the diagonal processes of the
2D process grid.
This routine is modified from gather_diag_to_all() in pzgstrs_Bglobal.c.
Here is the call graph for this function:
◆ pzgsequ()
| void pzgsequ | ( | SuperMatrix * | A, |
| double * | r, | ||
| double * | c, | ||
| double * | rowcnd, | ||
| double * | colcnd, | ||
| double * | amax, | ||
| int * | info, | ||
| gridinfo_t * | grid | ||
| ) |
Purpose
=======
PZGSEQU computes row and column scalings intended to equilibrate an
M-by-N sparse matrix A and reduce its condition number. R returns the row
scale factors and C the column scale factors, chosen to try to make
the largest element in each row and column of the matrix B with
elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.
R(i) and C(j) are restricted to be between SMLNUM = smallest safe
number and BIGNUM = largest safe number. Use of these scaling
factors is not guaranteed to reduce the condition number of A but
works well in practice.
See supermatrix.h for the definition of 'SuperMatrix' structure.
Arguments
=========
A (input) SuperMatrix*
The matrix of dimension (A->nrow, A->ncol) whose equilibration
factors are to be computed. The type of A can be:
Stype = SLU_NR_loc; Dtype = SLU_Z; Mtype = SLU_GE.
R (output) double*, size A->nrow
If INFO = 0 or INFO > M, R contains the row scale factors
for A.
C (output) double*, size A->ncol
If INFO = 0, C contains the column scale factors for A.
ROWCND (output) double*
If INFO = 0 or INFO > M, ROWCND contains the ratio of the
smallest R(i) to the largest R(i). If ROWCND >= 0.1 and
AMAX is neither too large nor too small, it is not worth
scaling by R.
COLCND (output) double*
If INFO = 0, COLCND contains the ratio of the smallest
C(i) to the largest C(i). If COLCND >= 0.1, it is not
worth scaling by C.
AMAX (output) double*
Absolute value of largest matrix element. If AMAX is very
close to overflow or very close to underflow, the matrix
should be scaled.
INFO (output) int*
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, and i is
<= M: the i-th row of A is exactly zero
> M: the (i-M)-th column of A is exactly zero
GRID (input) gridinof_t*
The 2D process mesh.
=====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsmv()
| void pzgsmv | ( | int_t | abs, |
| SuperMatrix * | A_internal, | ||
| gridinfo_t * | grid, | ||
| pzgsmv_comm_t * | gsmv_comm, | ||
| doublecomplex | x[], | ||
| doublecomplex | ax[] | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsmv_AXglobal()
| int pzgsmv_AXglobal | ( | int_t | m, |
| int_t | update[], | ||
| doublecomplex | val[], | ||
| int_t | bindx[], | ||
| doublecomplex | X[], | ||
| doublecomplex | ax[] | ||
| ) |
Performs sparse matrix-vector multiplication.
- val/bindx stores the distributed MSR matrix A
- X is global
- ax product is distributed the same way as A
Here is the caller graph for this function:
◆ pzgsmv_AXglobal_abs()
| int pzgsmv_AXglobal_abs | ( | int_t | m, |
| int_t | update[], | ||
| doublecomplex | val[], | ||
| int_t | bindx[], | ||
| doublecomplex | X[], | ||
| double | ax[] | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsmv_AXglobal_setup()
| int pzgsmv_AXglobal_setup | ( | SuperMatrix * | , |
| Glu_persist_t * | , | ||
| gridinfo_t * | , | ||
| int_t * | , | ||
| int_t * | [], | ||
| doublecomplex * | [], | ||
| int_t * | [], | ||
| int_t | [] | ||
| ) |
Here is the caller graph for this function:
◆ pzgsmv_finalize()
| void pzgsmv_finalize | ( | pzgsmv_comm_t * | gsmv_comm | ) |
Here is the caller graph for this function:
◆ pzgsmv_init()
| void pzgsmv_init | ( | SuperMatrix * | A, |
| int_t * | row_to_proc, | ||
| gridinfo_t * | grid, | ||
| pzgsmv_comm_t * | gsmv_comm | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsrfs()
| void pzgsrfs | ( | superlu_dist_options_t * | , |
| int_t | , | ||
| SuperMatrix * | , | ||
| double | , | ||
| zLUstruct_t * | , | ||
| zScalePermstruct_t * | , | ||
| gridinfo_t * | , | ||
| doublecomplex | [], | ||
| int_t | , | ||
| doublecomplex | [], | ||
| int_t | , | ||
| int | , | ||
| zSOLVEstruct_t * | , | ||
| double * | , | ||
| SuperLUStat_t * | , | ||
| int * | |||
| ) |
Here is the caller graph for this function:
◆ pzgsrfs3d()
| void pzgsrfs3d | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| double | anorm, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| doublecomplex * | B, | ||
| int_t | ldb, | ||
| doublecomplex * | X, | ||
| int_t | ldx, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| double * | berr, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
=======
PZGSRFS3D improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates
for the solution.
Arguments
=========
options (input) superlu_dist_options_t* (global)
The structure defines the input parameters to control
how the LU decomposition and triangular solve are performed.
n (input) int (global)
The order of the system of linear equations.
A (input) SuperMatrix*
The original matrix A, or the scaled A if equilibration was done.
A is also permuted into diag(R)*A*diag(C)*Pc'. The type of A can be:
Stype = SLU_NR_loc; Dtype = SLU_Z; Mtype = SLU_GE.
anorm (input) double
The norm of the original matrix A, or the scaled A if
equilibration was done.
LUstruct (input) zLUstruct_t*
The distributed data structures storing L and U factors.
The L and U factors are obtained from pdgstrf for
the possibly scaled and permuted matrix A.
See superlu_zdefs.h for the definition of 'zLUstruct_t'.
ScalePermstruct (input) zScalePermstruct_t* (global)
The data structure to store the scaling and permutation vectors
describing the transformations performed to the matrix A.
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
Grid can be initialized by subroutine SUPERLU_GRIDINIT.
See superlu_defs.h for the definition of 'gridinfo_t'.
B (input) doublecomplex* (local)
The m_loc-by-NRHS right-hand side matrix of the possibly
equilibrated system. That is, B may be overwritten by diag(R)*B.
ldb (input) int (local)
Leading dimension of matrix B.
X (input/output) doublecomplex* (local)
On entry, the solution matrix Y, as computed by PZGSTRS, of the
transformed system A1*Y = Pc*Pr*B. where
A1 = Pc*Pr*diag(R)*A*diag(C)*Pc' and Y = Pc*diag(C)^(-1)*X.
On exit, the improved solution matrix Y.
In order to obtain the solution X to the original system,
Y should be permutated by Pc^T, and premultiplied by diag(C)
if DiagScale = COL or BOTH.
This must be done after this routine is called.
ldx (input) int (local)
Leading dimension of matrix X.
nrhs (input) int
Number of right-hand sides.
SOLVEstruct (output) zSOLVEstruct_t* (global)
Contains the information for the communication during the
solution phase.
berr (output) double*, dimension (nrhs)
The componentwise relative backward error of each solution
vector X(j) (i.e., the smallest relative change in
any element of A or B that makes X(j) an exact solution).
stat (output) SuperLUStat_t*
Record the statistics about the refinement steps.
See util.h for the definition of SuperLUStat_t.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
Internal Parameters
===================
ITMAX is the maximum number of steps of iterative refinement.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsrfs_ABXglobal()
| void pzgsrfs_ABXglobal | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| double | anorm, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| doublecomplex * | B, | ||
| int_t | ldb, | ||
| doublecomplex * | X, | ||
| int_t | ldx, | ||
| int | nrhs, | ||
| double * | berr, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
=======
pzgsrfs_ABXglobal improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates
for the solution.
Arguments
=========
n (input) int (global)
The order of the system of linear equations.
A (input) SuperMatrix*
The original matrix A, or the scaled A if equilibration was done.
A is also permuted into the form Pc*Pr*A*Pc', where Pr and Pc
are permutation matrices. The type of A can be:
Stype = SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE.
NOTE: Currently, A must reside in all processes when calling
this routine.
anorm (input) double
The norm of the original matrix A, or the scaled A if
equilibration was done.
LUstruct (input) zLUstruct_t*
The distributed data structures storing L and U factors.
The L and U factors are obtained from pzgstrf for
the possibly scaled and permuted matrix A.
See superlu_ddefs.h for the definition of 'zLUstruct_t'.
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
Grid can be initialized by subroutine SUPERLU_GRIDINIT.
See superlu_ddefs.h for the definition of 'gridinfo_t'.
B (input) doublecomplex* (global)
The N-by-NRHS right-hand side matrix of the possibly equilibrated
and row permuted system.
NOTE: Currently, B must reside on all processes when calling
this routine.
ldb (input) int (global)
Leading dimension of matrix B.
X (input/output) doublecomplex* (global)
On entry, the solution matrix X, as computed by PZGSTRS.
On exit, the improved solution matrix X.
If DiagScale = COL or BOTH, X should be premultiplied by diag(C)
in order to obtain the solution to the original system.
NOTE: Currently, X must reside on all processes when calling
this routine.
ldx (input) int (global)
Leading dimension of matrix X.
nrhs (input) int
Number of right-hand sides.
berr (output) double*, dimension (nrhs)
The componentwise relative backward error of each solution
vector X(j) (i.e., the smallest relative change in
any element of A or B that makes X(j) an exact solution).
stat (output) SuperLUStat_t*
Record the statistics about the refinement steps.
See util.h for the definition of SuperLUStat_t.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
Internal Parameters
===================
ITMAX is the maximum number of steps of iterative refinement.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgssvx()
| void pzgssvx | ( | superlu_dist_options_t * | , |
| SuperMatrix * | , | ||
| zScalePermstruct_t * | , | ||
| doublecomplex * | , | ||
| int | , | ||
| int | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| zSOLVEstruct_t * | , | ||
| double * | , | ||
| SuperLUStat_t * | , | ||
| int * | |||
| ) |
Here is the caller graph for this function:
◆ pzgssvx3d()
| void pzgssvx3d | ( | superlu_dist_options_t * | options, |
| SuperMatrix * | A, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| doublecomplex | B[], | ||
| int | ldb, | ||
| int | nrhs, | ||
| gridinfo3d_t * | grid3d, | ||
| zLUstruct_t * | LUstruct, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| double * | berr, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Here is the caller graph for this function:
◆ pzgssvx3d_csc_batch()
| int pzgssvx3d_csc_batch | ( | superlu_dist_options_t * | options, |
| int | batchCount, | ||
| int | m, | ||
| int | n, | ||
| int | nnz, | ||
| int | nrhs, | ||
| handle_t * | SparseMatrix_handles, | ||
| doublecomplex ** | RHSptr, | ||
| int * | ldRHS, | ||
| double ** | ReqPtr, | ||
| double ** | CeqPtr, | ||
| int ** | RpivPtr, | ||
| int ** | CpivPtr, | ||
| DiagScale_t * | DiagScale, | ||
| handle_t * | F, | ||
| doublecomplex ** | Xptr, | ||
| int * | ldX, | ||
| double ** | Berrs, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Solve a batch of linear systems Ai * Xi = Bi with direct method, computing the LU factorization of each matrix Ai;
This is the fixed-size interface: all the input matrices have the same sparsity structure.
- Parameters
-
[in] options solver options [in] batchCount number of matrices in the batch [in] m row dimension of the matrices [in] n column dimension of the matrices [in] nnz number of non-zero entries in each matrix [in] nrhs number of right-hand-sides [in,out] SparseMatrix_handles array of sparse matrix handles, of size 'batchCount', each pointing to the actual storage in CSC format, see 'NCformat' in SuperMatix structure Each A is overwritten by row/col scaling R*A*C [in,out] RHSptr array of pointers to dense storage of right-hand sides B Each B is overwritten by row/col scaling R*B*C [in] ldRHS array of leading dimensions of RHS [in,out] ReqPtr array of pointers to diagonal row scaling vectors R, each of size m ReqPtr[] are allocated internally if equilibration is asked for [in,out] CeqPtr array of pointers to diagonal colum scaling vectors C, each of size n CeqPtr[] are allocated internally if equilibration is asked for [in,out] RpivPtr array of pointers to row permutation vectors, each of size m [in,out] CpivPtr array of pointers to column permutation vectors, each of size n [in,out] DiagScale array of indicators how equilibration is done for each matrix [out] F array of handles pointing to the factored matrices [out] Xptr array of pointers to dense storage of solution [in] ldX array of leading dimensions of X [out] Berrs array of poiniters to backward errors [in]
- Parameters
-
[out] stat records algorithms statistics such as runtime, memory usage, etc. [out] info flags the errors on return
!!! CHECK SETTING: TO BE SURE TO USE GPU VERSIONS !!!! gpu3dVersion superlu_acc_offload
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgssvx_ABglobal()
| void pzgssvx_ABglobal | ( | superlu_dist_options_t * | , |
| SuperMatrix * | , | ||
| zScalePermstruct_t * | , | ||
| doublecomplex * | , | ||
| int | , | ||
| int | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| double * | , | ||
| SuperLUStat_t * | , | ||
| int * | |||
| ) |
Here is the caller graph for this function:
◆ pzgsTrBackSolve3d()
| int_t pzgsTrBackSolve3d | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x3d, | ||
| doublecomplex * | lsum3d, | ||
| zxT_struct * | xT_s, | ||
| doublecomplex * | recvbuf, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Loop over all the levels from root to leaf
Adding dlsumBmod_buff_t* lbmod_buf
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsTrBackSolve3d_newsolve()
| int_t pzgsTrBackSolve3d_newsolve | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x3d, | ||
| doublecomplex * | lsum3d, | ||
| doublecomplex * | recvbuf, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Adding dlsumBmod_buff_t* lbmod_buf
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrf()
| int_t pzgstrf | ( | superlu_dist_options_t * | options, |
| int | m, | ||
| int | n, | ||
| double | anorm, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
=======
PZGSTRF performs the LU factorization in parallel.
Arguments
=========
options (input) superlu_dist_options_t*
The structure defines the input parameters to control
how the LU decomposition will be performed.
The following field should be defined:
o ReplaceTinyPivot (yes_no_t)
= NO: do not modify pivots
= YES: replace tiny pivots by sqrt(epsilon)*norm(A) during
LU factorization.
m (input) int
Number of rows in the matrix.
n (input) int
Number of columns in the matrix.
anorm (input) double
The norm of the original matrix A, or the scaled A if
equilibration was done.
LUstruct (input/output) zLUstruct_t*
The data structures to store the distributed L and U factors.
The following fields should be defined:
o Glu_persist (input) Glu_persist_t*
Global data structure (xsup, supno) replicated on all processes,
describing the supernode partition in the factored matrices
L and U:
xsup[s] is the leading column of the s-th supernode,
supno[i] is the supernode number to which column i belongs.
o Llu (input/output) zLocalLU_t*
The distributed data structures to store L and U factors.
See superlu_zdefs.h for the definition of 'zLocalLU_t'.
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
Grid can be initialized by subroutine SUPERLU_GRIDINIT.
See superlu_ddefs.h for the definition of 'gridinfo_t'.
stat (output) SuperLUStat_t*
Record the statistics on runtime and floating-point operation count.
See util.h for the definition of 'SuperLUStat_t'.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
> 0: if info = i, U(i,i) is exactly zero. The factorization has
been completed, but the factor U is exactly singular,
and division by zero will occur if it is used to solve a
system of equations.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrf2()
| void pzgstrf2 | ( | superlu_dist_options_t * | , |
| int_t | nsupers, | ||
| int_t | k0, | ||
| int_t | k, | ||
| double | thresh, | ||
| Glu_persist_t * | , | ||
| gridinfo_t * | , | ||
| zLocalLU_t * | , | ||
| MPI_Request * | , | ||
| int | , | ||
| SuperLUStat_t * | , | ||
| int * | |||
| ) |
◆ pzgstrf2_trsm()
| void pzgstrf2_trsm | ( | superlu_dist_options_t * | options, |
| int_t | k0, | ||
| int_t | k, | ||
| double | thresh, | ||
| Glu_persist_t * | Glu_persist, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request * | U_diag_blk_send_req, | ||
| int | tag_ub, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
=======
Panel factorization -- block column k
Factor diagonal and subdiagonal blocks and test for exact singularity.
Only the column processes that own block column *k* participate
in the work.
Arguments
=========
options (input) superlu_dist_options_t* (global)
The structure defines the input parameters to control
how the LU decomposition will be performed.
k0 (input) int (global)
Counter of the next supernode to be factorized.
k (input) int (global)
The column number of the block column to be factorized.
thresh (input) double (global)
The threshold value = s_eps * anorm.
Glu_persist (input) Glu_persist_t*
Global data structures (xsup, supno) replicated on all processes.
grid (input) gridinfo_t*
The 2D process mesh.
Llu (input/output) zLocalLU_t*
Local data structures to store distributed L and U matrices.
U_diag_blk_send_req (input/output) MPI_Request*
List of send requests to send down the diagonal block of U.
tag_ub (input) int
Upper bound of MPI tag values.
stat (output) SuperLUStat_t*
Record the statistics about the factorization.
See SuperLUStat_t structure defined in util.h.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
> 0: if info = i, U(i,i) is exactly zero. The factorization has
been completed, but the factor U is exactly singular,
and division by zero will occur if it is used to solve a
system of equations.
ALWAYS SEND TO ALL OTHERS - TO FIX
Here is the call graph for this function:
◆ pzgstrf3d()
| int_t pzgstrf3d | ( | superlu_dist_options_t * | options, |
| int | m, | ||
| int | n, | ||
| double | anorm, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| SCT_t * | SCT, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsTrForwardSolve3d()
| int_t pzgsTrForwardSolve3d | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x3d, | ||
| doublecomplex * | lsum3d, | ||
| zxT_struct * | xT_s, | ||
| doublecomplex * | recvbuf, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Loop over all the levels from root to leaf
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgsTrForwardSolve3d_newsolve()
| int_t pzgsTrForwardSolve3d_newsolve | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x3d, | ||
| doublecomplex * | lsum3d, | ||
| doublecomplex * | recvbuf, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrs()
| void pzgstrs | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| gridinfo_t * | grid, | ||
| doublecomplex * | B, | ||
| int_t | m_loc, | ||
| int_t | fst_row, | ||
| int_t | ldb, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
=======
PZGSTRS solves a system of distributed linear equations
A*X = B with a general N-by-N matrix A using the LU factorization
computed by PZGSTRF.
If the equilibration, and row and column permutations were performed,
the LU factorization was performed for A1 where
A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U
and the linear system solved is
A1 * Y = Pc*Pr*B1, where B was overwritten by B1 = diag(R)*B, and
the permutation to B1 by Pc*Pr is applied internally in this routine.
Arguments
=========
options (input) superlu_dist_options_t*
The structure defines the input parameters to control
how the LU decomposition and triangular solve are performed.
n (input) int (global)
The order of the system of linear equations.
LUstruct (input) zLUstruct_t*
The distributed data structures storing L and U factors.
The L and U factors are obtained from PZGSTRF for
the possibly scaled and permuted matrix A.
See superlu_zdefs.h for the definition of 'zLUstruct_t'.
A may be scaled and permuted into A1, so that
A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
Grid can be initialized by subroutine SUPERLU_GRIDINIT.
See superlu_defs.h for the definition of 'gridinfo_t'.
B (input/output) doublecomplex*
On entry, the distributed right-hand side matrix of the possibly
equilibrated system. That is, B may be overwritten by diag(R)*B.
On exit, the distributed solution matrix Y of the possibly
equilibrated system if info = 0, where Y = Pc*diag(C)^(-1)*X,
and X is the solution of the original system.
m_loc (input) int (local)
The local row dimension of matrix B.
fst_row (input) int (global)
The row number of B's first row in the global matrix.
ldb (input) int (local)
The leading dimension of matrix B.
nrhs (input) int (global)
Number of right-hand sides.
SOLVEstruct (input) zSOLVEstruct_t* (global)
Contains the information for the communication during the
solution phase.
stat (output) SuperLUStat_t*
Record the statistics about the triangular solves.
See util.h for the definition of 'SuperLUStat_t'.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrs2()
| void pzgstrs2 | ( | int_t | m, |
| int_t | k0, | ||
| int_t | k, | ||
| Glu_persist_t * | Glu_persist, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| SuperLUStat_t * | stat | ||
| ) |
◆ pzgstrs2_omp()
| void pzgstrs2_omp | ( | int_t | k0, |
| int_t | k, | ||
| Glu_persist_t * | Glu_persist, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| Ublock_info_t * | Ublock_info, | ||
| SuperLUStat_t * | stat | ||
| ) |
4/19/2019
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrs3d()
| void pzgstrs3d | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | B, | ||
| int_t | m_loc, | ||
| int_t | fst_row, | ||
| int_t | ldb, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
PZGSTRS solves a system of distributed linear equations
A*X = B with a general N-by-N matrix A using the LU factorization
computed by PZGSTRF.
If the equilibration, and row and column permutations were performed,
the LU factorization was performed for A1 where
A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U
and the linear system solved is
A1 * Y = Pc*Pr*B1, where B was overwritten by B1 = diag(R)*B, and
the permutation to B1 by Pc*Pr is applied internally in this routine.
Arguments
n (input) int (global)
The order of the system of linear equations.
LUstruct (input) zLUstruct_t*
The distributed data structures storing L and U factors.
The L and U factors are obtained from PZGSTRF for
the possibly scaled and permuted matrix A.
See superlu_ddefs.h for the definition of 'zLUstruct_t'.
A may be scaled and permuted into A1, so that
A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
Grid can be initialized by subroutine SUPERLU_GRIDINIT.
See superlu_defs.h for the definition of 'gridinfo_t'.
B (input/output) doublecomplex*
On entry, the distributed right-hand side matrix of the possibly
equilibrated system. That is, B may be overwritten by diag(R)*B.
On exit, the distributed solution matrix Y of the possibly
equilibrated system if info = 0, where Y = Pc*diag(C)^(-1)*X,
and X is the solution of the original system.
m_loc (input) int (local)
The local row dimension of matrix B.
fst_row (input) int (global)
The row number of B's first row in the global matrix.
ldb (input) int (local)
The leading dimension of matrix B.
nrhs (input) int (global)
Number of right-hand sides.
SOLVEstruct (input) zSOLVEstruct_t* (global)
Contains the information for the communication during the
solution phase.
stat (output) SuperLUStat_t*
Record the statistics about the triangular solves.
See util.h for the definition of 'SuperLUStat_t'.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
Initializing xT
Setup the headers for xT
Reduce the Solve flops from all the grids to grid zero
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrs3d_newsolve()
| void pzgstrs3d_newsolve | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | B, | ||
| int_t | m_loc, | ||
| int_t | fst_row, | ||
| int_t | ldb, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Reduce the Solve flops from all the grids to grid zero
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrs_Bglobal()
| void pzgstrs_Bglobal | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| doublecomplex * | B, | ||
| int_t | ldb, | ||
| int | nrhs, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Purpose
=======
pzgstrs_Bglobal solves a system of distributed linear equations
A*X = B with a general N-by-N matrix A using the LU factorization
computed by pzgstrf.
Arguments
=========
options (input) superlu_dist_options_t*
The structure defines the input parameters to control
how the LU decomposition and triangular solve are performed.
n (input) int (global)
The order of the system of linear equations.
LUstruct (input) zLUstruct_t*
The distributed data structures storing L and U factors.
The L and U factors are obtained from pzgstrf for
the possibly scaled and permuted matrix A.
See superlu_ddefs.h for the definition of 'zLUstruct_t'.
grid (input) gridinfo_t*
The 2D process mesh. It contains the MPI communicator, the number
of process rows (NPROW), the number of process columns (NPCOL),
and my process rank. It is an input argument to all the
parallel routines.
Grid can be initialized by subroutine SUPERLU_GRIDINIT.
See superlu_ddefs.h for the definition of 'gridinfo_t'.
B (input/output) doublecomplex*
On entry, the right-hand side matrix of the possibly equilibrated
and row permuted system.
On exit, the solution matrix of the possibly equilibrated
and row permuted system if info = 0;
NOTE: Currently, the N-by-NRHS matrix B must reside on all
processes when calling this routine.
ldb (input) int (global)
Leading dimension of matrix B.
nrhs (input) int (global)
Number of right-hand sides.
stat (output) SuperLUStat_t*
Record the statistics about the triangular solves.
See util.h for the definition of 'SuperLUStat_t'.
info (output) int*
= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzgstrs_delete_device_lsum_x()
| int_t pzgstrs_delete_device_lsum_x | ( | zSOLVEstruct_t * | SOLVEstruct | ) |
Here is the caller graph for this function:
◆ pzgstrs_init()
| int_t pzgstrs_init | ( | int_t | n, |
| int_t | m_loc, | ||
| int_t | nrhs, | ||
| int_t | fst_row, | ||
| int_t | perm_r[], | ||
| int_t | perm_c[], | ||
| gridinfo_t * | grid, | ||
| Glu_persist_t * | Glu_persist, | ||
| zSOLVEstruct_t * | SOLVEstruct | ||
| ) |
Purpose
=======
Set up the communication pattern for redistribution between B and X
in the triangular solution.
Arguments
=========
n (input) int (global)
The dimension of the linear system.
m_loc (input) int (local)
The local row dimension of the distributed input matrix.
nrhs (input) int (global)
Number of right-hand sides.
fst_row (input) int (global)
The row number of matrix B's first row in the global matrix.
perm_r (input) int* (global)
The row permutation vector.
perm_c (input) int* (global)
The column permutation vector.
grid (input) gridinfo_t*
The 2D process mesh.
Here is the caller graph for this function:
◆ pzgstrs_init_device_lsum_x()
| int_t pzgstrs_init_device_lsum_x | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| int_t | m_loc, | ||
| int_t | nrhs, | ||
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| int * | supernodeMask | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzinf_norm_error()
| void pzinf_norm_error | ( | int | iam, |
| int_t | n, | ||
| int_t | nrhs, | ||
| doublecomplex | x[], | ||
| int_t | ldx, | ||
| doublecomplex | xtrue[], | ||
| int_t | ldxtrue, | ||
| MPI_Comm | slucomm | ||
| ) |
Check the inf-norm of the error vector.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzlangs()
| double pzlangs | ( | char * | norm, |
| SuperMatrix * | A, | ||
| gridinfo_t * | grid | ||
| ) |
Purpose
=======
PZLANGS returns the value of the one norm, or the Frobenius norm, or
the infinity norm, or the element of largest absolute value of a
real matrix A.
Description
===========
PZLANGE returns the value
PZLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'
(
( norm1(A), NORM = '1', 'O' or 'o'
(
( normI(A), NORM = 'I' or 'i'
(
( normF(A), NORM = 'F', 'f', 'E' or 'e'
where norm1 denotes the one norm of a matrix (maximum column sum),
normI denotes the infinity norm of a matrix (maximum row sum) and
normF denotes the Frobenius norm of a matrix (square root of sum of
squares). Note that max(abs(A(i,j))) is not a matrix norm.
Arguments
=========
NORM (input) CHARACTER*1
Specifies the value to be returned in DLANGE as described above.
A (input) SuperMatrix*
The M by N sparse matrix A.
GRID (input) gridinof_t*
The 2D process mesh.
=====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzlaqgs()
| void pzlaqgs | ( | SuperMatrix * | A, |
| double * | r, | ||
| double * | c, | ||
| double | rowcnd, | ||
| double | colcnd, | ||
| double | amax, | ||
| char * | equed | ||
| ) |
Purpose
=======
PZLAQGS equilibrates a general sparse M by N matrix A using the row
and column scaling factors in the vectors R and C.
See supermatrix.h for the definition of 'SuperMatrix' structure.
Arguments
=========
A (input/output) SuperMatrix*
On exit, the equilibrated matrix. See EQUED for the form of
the equilibrated matrix. The type of A can be:
Stype = SLU_NR_loc; Dtype = SLU_Z; Mtype = SLU_GE.
R (input) double*, dimension (A->nrow)
The row scale factors for A.
C (input) double*, dimension (A->ncol)
The column scale factors for A.
ROWCND (input) double
Ratio of the smallest R(i) to the largest R(i).
COLCND (input) double
Ratio of the smallest C(i) to the largest C(i).
AMAX (input) double
Absolute value of largest matrix entry.
EQUED (output) char*
Specifies the form of equilibration that was done.
= 'N': No equilibration
= 'R': Row equilibration, i.e., A has been premultiplied by
diag(R).
= 'C': Column equilibration, i.e., A has been postmultiplied
by diag(C).
= 'B': Both row and column equilibration, i.e., A has been
replaced by diag(R) * A * diag(C).
Internal Parameters
===================
THRESH is a threshold value used to decide if row or column scaling
should be done based on the ratio of the row or column scaling
factors. If ROWCND < THRESH, row scaling is done, and if
COLCND < THRESH, column scaling is done.
LARGE and SMALL are threshold values used to decide if row scaling
should be done based on the absolute size of the largest matrix
element. If AMAX > LARGE or AMAX < SMALL, row scaling is done.
=====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzPermute_Dense_Matrix()
| int pzPermute_Dense_Matrix | ( | int_t | fst_row, |
| int_t | m_loc, | ||
| int_t | row_to_proc[], | ||
| int_t | perm[], | ||
| doublecomplex | X[], | ||
| int | ldx, | ||
| doublecomplex | B[], | ||
| int | ldb, | ||
| int | nrhs, | ||
| gridinfo_t * | grid | ||
| ) |
Permute the distributed dense matrix: B <= perm(X). perm[i] = j means the i-th row of X is in the j-th row of B.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzReDistribute3d_B_to_X()
| int_t pzReDistribute3d_B_to_X | ( | doublecomplex * | B, |
| int_t | m_loc, | ||
| int | nrhs, | ||
| int_t | ldb, | ||
| int_t | fst_row, | ||
| int_t * | ilsum, | ||
| doublecomplex * | x, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_persist_t * | Glu_persist, | ||
| gridinfo3d_t * | grid3d, | ||
| zSOLVEstruct_t * | SOLVEstruct | ||
| ) |
Purpose
Re-distribute B on the diagonal processes of the 2D process mesh (only on grid 0).
Note
This routine can only be called after the routine pxgstrs_init(),
in which the structures of the send and receive buffers are set up.
Arguments
B (input) doublecomplex*
The distributed right-hand side matrix of the possibly
equilibrated system.
m_loc (input) int (local)
The local row dimension of matrix B.
nrhs (input) int (global)
Number of right-hand sides.
ldb (input) int (local)
Leading dimension of matrix B.
fst_row (input) int (global)
The row number of B's first row in the global matrix.
ilsum (input) int* (global)
Starting position of each supernode in a full array.
x (output) doublecomplex*
The solution vector. It is valid only on the diagonal processes.
ScalePermstruct (input) dScalePermstruct_t*
The data structure to store the scaling and permutation vectors
describing the transformations performed to the original matrix A.
grid (input) gridinfo_t*
The 2D process mesh.
SOLVEstruct (input) dSOLVEstruct_t*
Contains the information for the communication during the
solution phase.
Return value
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzReDistribute3d_X_to_B()
| int_t pzReDistribute3d_X_to_B | ( | int_t | n, |
| doublecomplex * | B, | ||
| int_t | m_loc, | ||
| int_t | ldb, | ||
| int_t | fst_row, | ||
| int | nrhs, | ||
| doublecomplex * | x, | ||
| int_t * | ilsum, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_persist_t * | Glu_persist, | ||
| gridinfo3d_t * | grid3d, | ||
| zSOLVEstruct_t * | SOLVEstruct | ||
| ) |
Purpose Re-distribute X on the diagonal processes to B distributed on all the processes (only on grid 0) Note This routine can only be called after the routine pxgstrs_init(), in which the structures of the send and receive buffers are set up.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ pzReDistribute_B_to_X()
| int_t pzReDistribute_B_to_X | ( | doublecomplex * | B, |
| int_t | m_loc, | ||
| int | nrhs, | ||
| int_t | ldb, | ||
| int_t | fst_row, | ||
| int_t * | ilsum, | ||
| doublecomplex * | x, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_persist_t * | Glu_persist, | ||
| gridinfo_t * | grid, | ||
| zSOLVEstruct_t * | SOLVEstruct | ||
| ) |
Purpose ======= Re-distribute B on the diagonal processes of the 2D process mesh. Note ==== This routine can only be called after the routine pzgstrs_init(), in which the structures of the send and receive buffers are set up. Arguments ========= B (input) doublecomplex* The distributed right-hand side matrix of the possibly equilibrated system. m_loc (input) int (local) The local row dimension of matrix B. nrhs (input) int (global) Number of right-hand sides. ldb (input) int (local) Leading dimension of matrix B. fst_row (input) int (global) The row number of B's first row in the global matrix. ilsum (input) int* (global) Starting position of each supernode in a full array. x (output) doublecomplex* The solution vector. It is valid only on the diagonal processes. ScalePermstruct (input) zScalePermstruct_t* The data structure to store the scaling and permutation vectors describing the transformations performed to the original matrix A. grid (input) gridinfo_t* The 2D process mesh. SOLVEstruct (input) zSOLVEstruct_t* Contains the information for the communication during the solution phase. Return value ============
Here is the call graph for this function:
Here is the caller graph for this function:
◆ scuStatUpdate()
| int_t scuStatUpdate | ( | int_t | knsupc, |
| HyP_t * | HyP, | ||
| SCT_t * | SCT, | ||
| SuperLUStat_t * | stat | ||
| ) |
◆ sp_zgemm_dist()
| int sp_zgemm_dist | ( | char * | transa, |
| int | n, | ||
| doublecomplex | alpha, | ||
| SuperMatrix * | A, | ||
| doublecomplex * | b, | ||
| int | ldb, | ||
| doublecomplex | beta, | ||
| doublecomplex * | c, | ||
| int | ldc | ||
| ) |
Purpose
=======
sp_zgemm_dist performs one of the matrix-matrix operations
C := alpha*op( A )*op( B ) + beta*C,
where op( X ) is one of
op( X ) = X or op( X ) = X' or op( X ) = conjg( X' ),
alpha and beta are scalars, and A, B and C are matrices, with op( A )
an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
Parameters
==========
TRANSA - (input) char*
On entry, TRANSA specifies the form of op( A ) to be used in
the matrix multiplication as follows:
TRANSA = 'N' or 'n', op( A ) = A.
TRANSA = 'T' or 't', op( A ) = A'.
TRANSA = 'C' or 'c', op( A ) = conjg( A' ).
Unchanged on exit.
TRANSB - (input) char*
On entry, TRANSB specifies the form of op( B ) to be used in
the matrix multiplication as follows:
TRANSB = 'N' or 'n', op( B ) = B.
TRANSB = 'T' or 't', op( B ) = B'.
TRANSB = 'C' or 'c', op( B ) = conjg( B' ).
Unchanged on exit.
M - (input) int
On entry, M specifies the number of rows of the matrix
op( A ) and of the matrix C. M must be at least zero.
Unchanged on exit.
N - (input) int
On entry, N specifies the number of columns of the matrix
op( B ) and the number of columns of the matrix C. N must be
at least zero.
Unchanged on exit.
K - (input) int
On entry, K specifies the number of columns of the matrix
op( A ) and the number of rows of the matrix op( B ). K must
be at least zero.
Unchanged on exit.
ALPHA - (input) doublecomplex
On entry, ALPHA specifies the scalar alpha.
A - (input) SuperMatrix*
Matrix A with a sparse format, of dimension (A->nrow, A->ncol).
Currently, the type of A can be:
Stype = NC or NCP; Dtype = SLU_Z; Mtype = GE.
In the future, more general A can be handled.
B - doublecomplex array of DIMENSION ( LDB, kb ), where kb is
n when TRANSB = 'N' or 'n', and is k otherwise.
Before entry with TRANSB = 'N' or 'n', the leading k by n
part of the array B must contain the matrix B, otherwise
the leading n by k part of the array B must contain the
matrix B.
Unchanged on exit.
LDB - (input) int
On entry, LDB specifies the first dimension of B as declared
in the calling (sub) program. LDB must be at least max( 1, n ).
Unchanged on exit.
BETA - (input) doublecomplex
On entry, BETA specifies the scalar beta. When BETA is
supplied as zero then C need not be set on input.
C - doublecomplex array of DIMENSION ( LDC, n ).
Before entry, the leading m by n part of the array C must
contain the matrix C, except when beta is zero, in which
case C need not be set on entry.
On exit, the array C is overwritten by the m by n matrix
( alpha*op( A )*B + beta*C ).
LDC - (input) int
On entry, LDC specifies the first dimension of C as declared
in the calling (sub)program. LDC must be at least max(1,m).
Unchanged on exit.
==== Sparse Level 3 Blas routine.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ sp_zgemv_dist()
| int sp_zgemv_dist | ( | char * | trans, |
| doublecomplex | alpha, | ||
| SuperMatrix * | A, | ||
| doublecomplex * | x, | ||
| int | incx, | ||
| doublecomplex | beta, | ||
| doublecomplex * | y, | ||
| int | incy | ||
| ) |
SpGEMV.
Purpose
=======
sp_zgemv_dist() performs one of the matrix-vector operations
y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,
where alpha and beta are scalars, x and y are vectors and A is a
sparse A->nrow by A->ncol matrix.
Parameters
==========
TRANS - (input) char*
On entry, TRANS specifies the operation to be performed as
follows:
TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
TRANS = 'T' or 't' y := alpha*A'*x + beta*y.
TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.
ALPHA - (input) double
On entry, ALPHA specifies the scalar alpha.
A - (input) SuperMatrix*
Matrix A with a sparse format, of dimension (A->nrow, A->ncol).
Currently, the type of A can be:
Stype = SLU_NC or SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE.
In the future, more general A can be handled.
X - (input) doublecomplex*, array of DIMENSION at least
( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
and at least
( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
Before entry, the incremented array X must contain the
vector x.
INCX - (input) int
On entry, INCX specifies the increment for the elements of
X. INCX must not be zero.
BETA - (input) doublecomplex
On entry, BETA specifies the scalar beta. When BETA is
supplied as zero then Y need not be set on input.
Y - (output) doublecomplex*, array of DIMENSION at least
( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
and at least
( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
Before entry with BETA non-zero, the incremented array Y
must contain the vector y. On exit, Y is overwritten by the
updated vector y.
INCY - (input) int
On entry, INCY specifies the increment for the elements of
Y. INCY must not be zero.
==== Sparse Level 2 Blas routine.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ sp_ztrsv_dist()
| int sp_ztrsv_dist | ( | char * | uplo, |
| char * | trans, | ||
| char * | diag, | ||
| SuperMatrix * | L, | ||
| SuperMatrix * | U, | ||
| doublecomplex * | x, | ||
| int * | info | ||
| ) |
Purpose ======= sp_ztrsv_dist() solves one of the systems of equations A*x = b, or A'*x = b, where b and x are n element vectors and A is a sparse unit , or non-unit, upper or lower triangular matrix. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine. Parameters ========== uplo - (input) char* On entry, uplo specifies whether the matrix is an upper or lower triangular matrix as follows: uplo = 'U' or 'u' A is an upper triangular matrix. uplo = 'L' or 'l' A is a lower triangular matrix. trans - (input) char* On entry, trans specifies the equations to be solved as follows: trans = 'N' or 'n' A*x = b. trans = 'T' or 't' A'*x = b. trans = 'C' or 'c' A'*x = b. diag - (input) char* On entry, diag specifies whether or not A is unit triangular as follows: diag = 'U' or 'u' A is assumed to be unit triangular. diag = 'N' or 'n' A is not assumed to be unit triangular. L - (input) SuperMatrix* The factor L from the factorization Pr*A*Pc=L*U. Use compressed row subscripts storage for supernodes, i.e., L has types: Stype = SLU_SC, Dtype = SLU_Z, Mtype = SLU_TRLU. U - (input) SuperMatrix* The factor U from the factorization Pr*A*Pc=L*U. U has types: Stype = SLU_NC, Dtype = SLU_Z, Mtype = SLU_TRU. x - (input/output) doublecomplex* Before entry, the incremented array X must contain the n element right-hand side vector b. On exit, X is overwritten with the solution vector x. info - (output) int* If *info = -i, the i-th argument had an illegal value.
Here is the call graph for this function:
◆ superlu_zaxpy()
| int superlu_zaxpy | ( | const int | n, |
| const doublecomplex | alpha, | ||
| const doublecomplex * | x, | ||
| const int | incx, | ||
| doublecomplex * | y, | ||
| const int | incy | ||
| ) |
Here is the caller graph for this function:
◆ superlu_zgemm()
| int superlu_zgemm | ( | const char * | transa, |
| const char * | transb, | ||
| int | m, | ||
| int | n, | ||
| int | k, | ||
| doublecomplex | alpha, | ||
| doublecomplex * | a, | ||
| int | lda, | ||
| doublecomplex * | b, | ||
| int | ldb, | ||
| doublecomplex | beta, | ||
| doublecomplex * | c, | ||
| int | ldc | ||
| ) |
Here is the caller graph for this function:
◆ superlu_zgemv()
| int superlu_zgemv | ( | const char * | trans, |
| const int | m, | ||
| const int | n, | ||
| const doublecomplex | alpha, | ||
| const doublecomplex * | a, | ||
| const int | lda, | ||
| const doublecomplex * | x, | ||
| const int | incx, | ||
| const doublecomplex | beta, | ||
| doublecomplex * | y, | ||
| const int | incy | ||
| ) |
◆ superlu_zger()
| int superlu_zger | ( | const int | m, |
| const int | n, | ||
| const doublecomplex | alpha, | ||
| const doublecomplex * | x, | ||
| const int | incx, | ||
| const doublecomplex * | y, | ||
| const int | incy, | ||
| doublecomplex * | a, | ||
| const int | lda | ||
| ) |
Here is the caller graph for this function:
◆ superlu_zscal()
| int superlu_zscal | ( | const int | n, |
| const doublecomplex | alpha, | ||
| doublecomplex * | x, | ||
| const int | incx | ||
| ) |
Here is the caller graph for this function:
◆ superlu_ztrsm()
| int superlu_ztrsm | ( | const char * | sideRL, |
| const char * | uplo, | ||
| const char * | transa, | ||
| const char * | diag, | ||
| const int | m, | ||
| const int | n, | ||
| const doublecomplex | alpha, | ||
| const doublecomplex * | a, | ||
| const int | lda, | ||
| doublecomplex * | b, | ||
| const int | ldb | ||
| ) |
Here is the caller graph for this function:
◆ superlu_ztrsv()
| int superlu_ztrsv | ( | char * | uplo, |
| char * | trans, | ||
| char * | diag, | ||
| int | n, | ||
| doublecomplex * | a, | ||
| int | lda, | ||
| doublecomplex * | x, | ||
| int | incx | ||
| ) |
◆ updateDirtyBit()
| int updateDirtyBit | ( | int_t | k0, |
| HyP_t * | HyP, | ||
| gridinfo_t * | grid | ||
| ) |
◆ validateInput_pzgssvx3d()
| void validateInput_pzgssvx3d | ( | superlu_dist_options_t * | options, |
| SuperMatrix * | A, | ||
| int | ldb, | ||
| int | nrhs, | ||
| gridinfo3d_t * | grid3d, | ||
| int * | info | ||
| ) |
Validates the input parameters for a given problem.
This function checks the input parameters for a given problem and sets the error code in the 'info' variable accordingly. If there is an error, it prints an error message and returns.
- Parameters
-
[in] options Pointer to the options structure containing Fact, RowPerm, ColPerm, and IterRefine values. [in] A Pointer to the matrix A structure containing nrow, ncol, Stype, Dtype, and Mtype values. [in] ldb The leading dimension of the array B. [in] nrhs The number of right-hand sides. [in] grid Pointer to the grid structure. [out] info Pointer to an integer variable that stores the error code.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ z3D_printMemUse()
| void z3D_printMemUse | ( | ztrf3Dpartition_t * | trf3Dpartition, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ z_c2cpp_GetHWPM()
| int z_c2cpp_GetHWPM | ( | SuperMatrix * | A, |
| gridinfo_t * | grid, | ||
| zScalePermstruct_t * | ScalePermstruct | ||
| ) |
Purpose
=======
Get heavy-weight perfect matching (HWPM).
Reference:
Arguments
=========
A (input) SuperMatrix*
The distributed input matrix A of dimension (A->nrow, A->ncol).
The type of A can be: Stype = SLU_NR_loc; Dtype = SLU_D; Mtype = SLU_GE.
grid (input) gridinfo_t*
SuperLU's 2D process mesh.
ScalePermstruct (output) zScalePermstruct_t*
ScalePermstruct->perm_r stores the permutation obtained from HWPM.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zallocateA_dist()
| void zallocateA_dist | ( | int_t | n, |
| int_t | nnz, | ||
| doublecomplex ** | a, | ||
| int_t ** | asub, | ||
| int_t ** | xa | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zAllocGlu_3d()
| int zAllocGlu_3d | ( | int_t | n, |
| int_t | nsupers, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Here is the call graph for this function:
◆ zAllocLlu_3d()
| int_t zAllocLlu_3d | ( | int_t | nsupers, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zallocScalePermstruct_RC()
| void zallocScalePermstruct_RC | ( | zScalePermstruct_t * | , |
| int_t | m, | ||
| int_t | n | ||
| ) |
Here is the caller graph for this function:
◆ zaxpy_()
| int zaxpy_ | ( | const int * | n, |
| const doublecomplex * | alpha, | ||
| const doublecomplex * | x, | ||
| const int * | incx, | ||
| doublecomplex * | y, | ||
| const int * | incy | ||
| ) |
◆ zBcast_LPanel()
| int_t zBcast_LPanel | ( | int_t | k, |
| int_t | k0, | ||
| int_t * | lsub, | ||
| doublecomplex * | lusup, | ||
| gridinfo_t * | , | ||
| int * | msgcnt, | ||
| int ** | ToSendR, | ||
| int_t * | xsup, | ||
| SCT_t * | , | ||
| int | |||
| ) |
◆ zBcast_UPanel()
| int_t zBcast_UPanel | ( | int_t | k, |
| int_t | k0, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| gridinfo_t * | , | ||
| int * | msgcnt, | ||
| int * | ToSendD, | ||
| SCT_t * | , | ||
| int | |||
| ) |
◆ zbcastPermutedSparseA()
| void zbcastPermutedSparseA | ( | SuperMatrix * | A, |
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zbCastXk2Pck()
| int_t zbCastXk2Pck | ( | int_t | k, |
| zxT_struct * | xT_s, | ||
| int | nrhs, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the caller graph for this function:
◆ zblock_gemm_scatter()
| void zblock_gemm_scatter | ( | int_t | lb, |
| int_t | j, | ||
| Ublock_info_t * | Ublock_info, | ||
| Remain_info_t * | Remain_info, | ||
| doublecomplex * | L_mat, | ||
| int | ldl, | ||
| doublecomplex * | U_mat, | ||
| int | ldu, | ||
| doublecomplex * | bigV, | ||
| int_t | knsupc, | ||
| int_t | klst, | ||
| int_t * | lsub, | ||
| int_t * | usub, | ||
| int_t | ldt, | ||
| int_t | thread_id, | ||
| int * | indirect, | ||
| int * | indirect2, | ||
| int_t ** | Lrowind_bc_ptr, | ||
| doublecomplex ** | Lnzval_bc_ptr, | ||
| int_t ** | Ufstnz_br_ptr, | ||
| doublecomplex ** | Unzval_br_ptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | , | ||
| SuperLUStat_t * | |||
| ) |
◆ zblock_gemm_scatterBottomLeft()
| int_t zblock_gemm_scatterBottomLeft | ( | int_t | lb, |
| int_t | j, | ||
| doublecomplex * | bigV, | ||
| int_t | knsupc, | ||
| int_t | klst, | ||
| int_t * | lsub, | ||
| int_t * | usub, | ||
| int_t | ldt, | ||
| int * | indirect, | ||
| int * | indirect2, | ||
| HyP_t * | HyP, | ||
| zLUstruct_t * | , | ||
| gridinfo_t * | , | ||
| SCT_t * | SCT, | ||
| SuperLUStat_t * | |||
| ) |
◆ zblock_gemm_scatterBottomRight()
| int_t zblock_gemm_scatterBottomRight | ( | int_t | lb, |
| int_t | j, | ||
| doublecomplex * | bigV, | ||
| int_t | knsupc, | ||
| int_t | klst, | ||
| int_t * | lsub, | ||
| int_t * | usub, | ||
| int_t | ldt, | ||
| int * | indirect, | ||
| int * | indirect2, | ||
| HyP_t * | HyP, | ||
| zLUstruct_t * | , | ||
| gridinfo_t * | , | ||
| SCT_t * | SCT, | ||
| SuperLUStat_t * | |||
| ) |
◆ zblock_gemm_scatterTopLeft()
| int_t zblock_gemm_scatterTopLeft | ( | int_t | lb, |
| int_t | j, | ||
| doublecomplex * | bigV, | ||
| int_t | knsupc, | ||
| int_t | klst, | ||
| int_t * | lsub, | ||
| int_t * | usub, | ||
| int_t | ldt, | ||
| int * | indirect, | ||
| int * | indirect2, | ||
| HyP_t * | HyP, | ||
| zLUstruct_t * | , | ||
| gridinfo_t * | , | ||
| SCT_t * | SCT, | ||
| SuperLUStat_t * | |||
| ) |
◆ zblock_gemm_scatterTopRight()
| int_t zblock_gemm_scatterTopRight | ( | int_t | lb, |
| int_t | j, | ||
| doublecomplex * | bigV, | ||
| int_t | knsupc, | ||
| int_t | klst, | ||
| int_t * | lsub, | ||
| int_t * | usub, | ||
| int_t | ldt, | ||
| int * | indirect, | ||
| int * | indirect2, | ||
| HyP_t * | HyP, | ||
| zLUstruct_t * | , | ||
| gridinfo_t * | , | ||
| SCT_t * | SCT, | ||
| SuperLUStat_t * | |||
| ) |
◆ zbroadcastAncestor3d()
| int_t zbroadcastAncestor3d | ( | ztrf3Dpartition_t * | trf3Dpartition, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
Here is the caller graph for this function:
◆ zbsolve_Xt_bcast()
| int_t zbsolve_Xt_bcast | ( | int_t | ilvl, |
| zxT_struct * | xT_s, | ||
| int | nrhs, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zcheckArr()
| int zcheckArr | ( | doublecomplex * | A, |
| doublecomplex * | B, | ||
| int | n | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zcheckLUFromDisk()
| int zcheckLUFromDisk | ( | int | nsupers, |
| int_t * | xsup, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zClone_CompRowLoc_Matrix_dist()
| void zClone_CompRowLoc_Matrix_dist | ( | SuperMatrix * | , |
| SuperMatrix * | |||
| ) |
◆ zcollect3dLpanels()
| int_t zcollect3dLpanels | ( | int_t | layer, |
| int_t | nsupers, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zcollect3dUpanels()
| int_t zcollect3dUpanels | ( | int_t | layer, |
| int_t | nsupers, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zCompCol_to_CompRow_dist()
| void zCompCol_to_CompRow_dist | ( | int_t | m, |
| int_t | n, | ||
| int_t | nnz, | ||
| doublecomplex * | a, | ||
| int_t * | colptr, | ||
| int_t * | rowind, | ||
| doublecomplex ** | at, | ||
| int_t ** | rowptr, | ||
| int_t ** | colind | ||
| ) |
Here is the caller graph for this function:
◆ zCompRow_to_CompCol_dist()
| void zCompRow_to_CompCol_dist | ( | int_t | , |
| int_t | , | ||
| int_t | , | ||
| doublecomplex * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| doublecomplex ** | , | ||
| int_t ** | , | ||
| int_t ** | |||
| ) |
Here is the caller graph for this function:
◆ zcomputeA_Norm()
| double zcomputeA_Norm | ( | int | notran, |
| SuperMatrix * | , | ||
| gridinfo_t * | |||
| ) |
Here is the caller graph for this function:
◆ zComputeLevelsets()
| void zComputeLevelsets | ( | int | , |
| int_t | , | ||
| gridinfo_t * | , | ||
| Glu_persist_t * | , | ||
| zLocalLU_t * | , | ||
| int_t * | |||
| ) |
◆ zCopy_CompCol_Matrix_dist()
| void zCopy_CompCol_Matrix_dist | ( | SuperMatrix * | , |
| SuperMatrix * | |||
| ) |
◆ zCopy_CompRowLoc_Matrix_dist()
| void zCopy_CompRowLoc_Matrix_dist | ( | SuperMatrix * | A, |
| SuperMatrix * | B | ||
| ) |
◆ zCopy_Dense_Matrix_dist()
| void zCopy_Dense_Matrix_dist | ( | int_t | , |
| int_t | , | ||
| doublecomplex * | , | ||
| int_t | , | ||
| doublecomplex * | , | ||
| int_t | |||
| ) |
Here is the caller graph for this function:
◆ zcreate_batch_systems()
| int zcreate_batch_systems | ( | handle_t * | SparseMatrix_handles, |
| int | batchCount, | ||
| int | nrhs, | ||
| doublecomplex ** | rhs, | ||
| int * | ldb, | ||
| doublecomplex ** | x, | ||
| int * | ldx, | ||
| FILE * | fp, | ||
| char * | postfix, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zcreate_block_diag_3d()
| int zcreate_block_diag_3d | ( | SuperMatrix * | A, |
| int | batchCount, | ||
| int | nrhs, | ||
| doublecomplex ** | rhs, | ||
| int * | ldb, | ||
| doublecomplex ** | x, | ||
| int * | ldx, | ||
| FILE * | fp, | ||
| char * | postfix, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zCreate_CompCol_Matrix_dist()
| void zCreate_CompCol_Matrix_dist | ( | SuperMatrix * | , |
| int_t | , | ||
| int_t | , | ||
| int_t | , | ||
| doublecomplex * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| Stype_t | , | ||
| Dtype_t | , | ||
| Mtype_t | |||
| ) |
Here is the caller graph for this function:
◆ zCreate_CompRowLoc_Matrix_dist()
| void zCreate_CompRowLoc_Matrix_dist | ( | SuperMatrix * | , |
| int_t | , | ||
| int_t | , | ||
| int_t | , | ||
| int_t | , | ||
| int_t | , | ||
| doublecomplex * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| Stype_t | , | ||
| Dtype_t | , | ||
| Mtype_t | |||
| ) |
Here is the caller graph for this function:
◆ zCreate_Dense_Matrix_dist()
| void zCreate_Dense_Matrix_dist | ( | SuperMatrix * | , |
| int_t | , | ||
| int_t | , | ||
| doublecomplex * | , | ||
| int_t | , | ||
| Stype_t | , | ||
| Dtype_t | , | ||
| Mtype_t | |||
| ) |
◆ zcreate_matrix()
| int zcreate_matrix | ( | SuperMatrix * | A, |
| int | nrhs, | ||
| doublecomplex ** | rhs, | ||
| int * | ldb, | ||
| doublecomplex ** | x, | ||
| int * | ldx, | ||
| FILE * | fp, | ||
| gridinfo_t * | grid | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zcreate_matrix3d()
| int zcreate_matrix3d | ( | SuperMatrix * | A, |
| int | nrhs, | ||
| doublecomplex ** | rhs, | ||
| int * | ldb, | ||
| doublecomplex ** | x, | ||
| int * | ldx, | ||
| FILE * | fp, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
◆ zcreate_matrix_dat()
| int zcreate_matrix_dat | ( | SuperMatrix * | , |
| int | , | ||
| doublecomplex ** | , | ||
| int * | , | ||
| doublecomplex ** | , | ||
| int * | , | ||
| FILE * | , | ||
| gridinfo_t * | |||
| ) |
◆ zcreate_matrix_postfix()
| int zcreate_matrix_postfix | ( | SuperMatrix * | A, |
| int | nrhs, | ||
| doublecomplex ** | rhs, | ||
| int * | ldb, | ||
| doublecomplex ** | x, | ||
| int * | ldx, | ||
| FILE * | fp, | ||
| char * | postfix, | ||
| gridinfo_t * | grid | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zcreate_matrix_postfix3d()
| int zcreate_matrix_postfix3d | ( | SuperMatrix * | A, |
| int | nrhs, | ||
| doublecomplex ** | rhs, | ||
| int * | ldb, | ||
| doublecomplex ** | x, | ||
| int * | ldx, | ||
| FILE * | fp, | ||
| char * | postfix, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zcreate_matrix_rb()
| int zcreate_matrix_rb | ( | SuperMatrix * | , |
| int | , | ||
| doublecomplex ** | , | ||
| int * | , | ||
| doublecomplex ** | , | ||
| int * | , | ||
| FILE * | , | ||
| gridinfo_t * | |||
| ) |
◆ zCreate_SuperNode_Matrix_dist()
| void zCreate_SuperNode_Matrix_dist | ( | SuperMatrix * | , |
| int_t | , | ||
| int_t | , | ||
| int_t | , | ||
| doublecomplex * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| Stype_t | , | ||
| Dtype_t | , | ||
| Mtype_t | |||
| ) |
◆ zDeAllocGlu_3d()
| int zDeAllocGlu_3d | ( | zLUstruct_t * | LUstruct | ) |
◆ zDeAllocLlu_3d()
| int zDeAllocLlu_3d | ( | int_t | n, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zdelete_multiGPU_buffers()
| void zdelete_multiGPU_buffers | ( | ) |
Here is the caller graph for this function:
◆ zdenseTreeFactor()
| int_t zdenseTreeFactor | ( | int_t | nnnodes, |
| int_t * | perm_c_supno, | ||
| commRequests_t * | comReqs, | ||
| zscuBufs_t * | scuBufs, | ||
| packLUInfo_t * | packLUInfo, | ||
| msgs_t * | msgs, | ||
| zLUValSubBuf_t * | LUvsb, | ||
| zdiagFactBufs_t * | dFBuf, | ||
| factStat_t * | factStat, | ||
| factNodelists_t * | fNlists, | ||
| superlu_dist_options_t * | options, | ||
| int_t * | gIperm_c_supno, | ||
| int_t | ldt, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat, | ||
| double | thresh, | ||
| SCT_t * | SCT, | ||
| int | tag_ub, | ||
| int * | info | ||
| ) |
◆ zDestroy_A3d_gathered_on_2d()
| void zDestroy_A3d_gathered_on_2d | ( | zSOLVEstruct_t * | SOLVEstruct, |
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the caller graph for this function:
◆ zDestroy_LU()
| void zDestroy_LU | ( | int_t | n, |
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Destroy distributed L & U matrices.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zDestroy_Tree()
| void zDestroy_Tree | ( | int_t | n, |
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Destroy broadcast and reduction trees used in triangular solve.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zDestroy_trf3Dpartition()
| void zDestroy_trf3Dpartition | ( | ztrf3Dpartition_t * | trf3Dpartition | ) |
Here is the caller graph for this function:
◆ zDiagFactIBCast()
| int_t zDiagFactIBCast | ( | int_t | k, |
| int_t | k0, | ||
| doublecomplex * | BlockUFactor, | ||
| doublecomplex * | BlockLFactor, | ||
| int * | IrecvPlcd_D, | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| superlu_dist_options_t * | , | ||
| double | thresh, | ||
| zLUstruct_t * | LUstruct, | ||
| SuperLUStat_t * | , | ||
| int * | info, | ||
| SCT_t * | , | ||
| int | tag_ub | ||
| ) |
◆ zdist_psymbtonum()
| float zdist_psymbtonum | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| Pslu_freeable_t * | Pslu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid | ||
| ) |
Purpose
=======
Distribute the input matrix onto the 2D process mesh.
Arguments
=========
options (input) superlu_dist_options_t*
The structure defines the input parameters to control
how the LU decomposition and triangular solve are performed.
options->Fact specifies whether or not the L and U structures
will be re-used:
= SamePattern_SameRowPerm: L and U structures are input, and
unchanged on exit.
This routine should not be called for this case, an error
is generated. Instead, pddistribute routine should be called.
= DOFACT or SamePattern: L and U structures are computed and output.
n (Input) int
Dimension of the matrix.
A (Input) SuperMatrix*
The distributed input matrix A of dimension (A->nrow, A->ncol).
A may be overwritten by diag(R)*A*diag(C)*Pc^T.
The type of A can be: Stype = NR; Dtype = SLU_D; Mtype = GE.
ScalePermstruct (Input) zScalePermstruct_t*
The data structure to store the scaling and permutation vectors
describing the transformations performed to the original matrix A.
Glu_freeable (Input) *Glu_freeable_t
The global structure describing the graph of L and U.
LUstruct (Input) zLUstruct_t*
Data structures for L and U factors.
grid (Input) gridinfo_t*
The 2D process mesh.
Return value
============
< 0, number of bytes allocated on return from the dist_symbLU
> 0, number of bytes allocated for performing the distribution
of the data, when out of memory.
(an approximation).
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zdistribute()
| float zdistribute | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid | ||
| ) |
Purpose ======= Distribute the matrix onto the 2D process mesh. Arguments ========= options (input) superlu_dist_options_t * options->Fact specifies whether or not the L and U structures will be re-used. = SamePattern_SameRowPerm: L and U structures are input, and unchanged on exit. = DOFACT or SamePattern: L and U structures are computed and output. n (input) int Dimension of the matrix. A (input) SuperMatrix* The original matrix A, permuted by columns, of dimension (A->nrow, A->ncol). The type of A can be: Stype = SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE. LUstruct (input) zLUstruct_t* Data structures for L and U factors. grid (input) gridinfo_t* The 2D process mesh. Return value ============ > 0, working storage (in bytes) required to perform redistribution. (excluding LU factor size)
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zDumpLblocks3D()
| void zDumpLblocks3D | ( | int_t | nsupers, |
| gridinfo3d_t * | grid3d, | ||
| Glu_persist_t * | Glu_persist, | ||
| zLocalLU_t * | Llu | ||
| ) |
Dump the factored matrix L using matlab triple-let format.
◆ zequil_batch()
| int zequil_batch | ( | superlu_dist_options_t * | options, |
| int | batchCount, | ||
| int | m, | ||
| int | n, | ||
| handle_t * | SparseMatrix_handles, | ||
| double ** | ReqPtr, | ||
| double ** | CeqPtr, | ||
| DiagScale_t * | DiagScale | ||
| ) |
Equilibrate the systems using the LAPACK-style algorithm.
- Parameters
-
[in] options solver options [in] batchCount number of matrices in the batch [in] m row dimension of the matrices [in] n column dimension of the matrices [in,out] SparseMatrix_handles pointers to the matrices in the batch, each pointing to the actual stoage in CSC format On entry, the original matrices On exit, each matrix may be overwritten by diag(R)*A*diag(C) [out] ReqPtr pointers to row scaling vectors (allocated internally) [out] CeqPtr pointers to column scaling vectors (allocated internally) [in,out] DiagScale arrays indicating how each system is equilibrated: {ROW, COL, BOTH}
Return value i: = 0: successful exit > 0: indicates the first matrix in the batch has zero row or column if i <= m: the i-th row of A is exactly zero if i > m: the (i-m)-th column of A is exactly zero
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zfill_dist()
| void zfill_dist | ( | doublecomplex * | a, |
| int_t | alen, | ||
| doublecomplex | dval | ||
| ) |
Fills a doublecomplex precision array with a given value.
◆ zFillRHS_dist()
| void zFillRHS_dist | ( | char * | trans, |
| int_t | nrhs, | ||
| doublecomplex * | x, | ||
| int_t | ldx, | ||
| SuperMatrix * | A, | ||
| doublecomplex * | rhs, | ||
| int_t | ldb | ||
| ) |
Let rhs[i] = sum of i-th row of A, so the solution vector is all 1's.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zfreeDiagFactBufsArr()
| int zfreeDiagFactBufsArr | ( | int | mxLeafNode, |
| zdiagFactBufs_t ** | dFBufs | ||
| ) |
Here is the caller graph for this function:
◆ zfreeScuBufs()
| int zfreeScuBufs | ( | zscuBufs_t * | scuBufs | ) |
Here is the caller graph for this function:
◆ zfsolveReduceLsum3d()
| int_t zfsolveReduceLsum3d | ( | int_t | treeId, |
| int_t | sender, | ||
| int_t | receiver, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | recvbuf, | ||
| int | nrhs, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the caller graph for this function:
◆ zgather_l()
| void zgather_l | ( | int_t | num_LBlk, |
| int_t | knsupc, | ||
| Remain_info_t * | L_info, | ||
| doublecomplex * | lval, | ||
| int_t | LD_lval, | ||
| doublecomplex * | L_buff | ||
| ) |
◆ zgather_u()
| void zgather_u | ( | int_t | num_u_blks, |
| Ublock_info_t * | Ublock_info, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| doublecomplex * | bigU, | ||
| int_t | ldu, | ||
| int_t * | xsup, | ||
| int_t | klst | ||
| ) |
◆ zgatherAllFactoredLU()
| int_t zgatherAllFactoredLU | ( | ztrf3Dpartition_t * | trf3Dpartition, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
Here is the caller graph for this function:
◆ zgatherAllFactoredLUFr()
| int_t zgatherAllFactoredLUFr | ( | int_t * | myZeroTrIdxs, |
| sForest_t * | sForests, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
◆ zgatherFactoredLU()
| int_t zgatherFactoredLU | ( | int_t | sender, |
| int_t | receiver, | ||
| int_t | nnodes, | ||
| int_t * | nodeList, | ||
| zLUValSubBuf_t * | LUvsb, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
◆ zGatherNRformat_loc3d()
| void zGatherNRformat_loc3d | ( | fact_t | Fact, |
| NRformat_loc * | A, | ||
| doublecomplex * | B, | ||
| int | ldb, | ||
| int | nrhs, | ||
| gridinfo3d_t * | grid3d, | ||
| NRformat_loc3d ** | |||
| ) |
◆ zGatherNRformat_loc3d_allgrid()
| void zGatherNRformat_loc3d_allgrid | ( | fact_t | Fact, |
| NRformat_loc * | A, | ||
| doublecomplex * | B, | ||
| int | ldb, | ||
| int | nrhs, | ||
| gridinfo3d_t * | grid3d, | ||
| NRformat_loc3d ** | |||
| ) |
Here is the caller graph for this function:
◆ zgemm_()
| int zgemm_ | ( | const char * | , |
| const char * | , | ||
| const int * | , | ||
| const int * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| const doublecomplex * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| doublecomplex * | , | ||
| const int * | |||
| ) |
Here is the caller graph for this function:
◆ zgemv_()
| void zgemv_ | ( | const char * | , |
| const int * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| const doublecomplex * | a, | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| doublecomplex * | , | ||
| const int * | |||
| ) |
Here is the caller graph for this function:
◆ zGenCOOLblocks()
| void zGenCOOLblocks | ( | int | , |
| int_t | , | ||
| gridinfo_t * | , | ||
| Glu_persist_t * | , | ||
| zLocalLU_t * | , | ||
| int_t ** | , | ||
| int_t ** | , | ||
| doublecomplex ** | , | ||
| int_t * | , | ||
| int_t * | |||
| ) |
◆ zGenCSCLblocks()
| void zGenCSCLblocks | ( | int | , |
| int_t | , | ||
| gridinfo_t * | , | ||
| Glu_persist_t * | , | ||
| zLocalLU_t * | , | ||
| doublecomplex ** | , | ||
| int_t ** | , | ||
| int_t ** | , | ||
| int_t * | , | ||
| int_t * | |||
| ) |
◆ zGenCSRLblocks()
| void zGenCSRLblocks | ( | int | , |
| int_t | , | ||
| gridinfo_t * | , | ||
| Glu_persist_t * | , | ||
| zLocalLU_t * | , | ||
| doublecomplex ** | , | ||
| int_t ** | , | ||
| int_t ** | , | ||
| int_t * | , | ||
| int_t * | |||
| ) |
◆ zGenXtrue_dist()
| void zGenXtrue_dist | ( | int_t | n, |
| int_t | nrhs, | ||
| doublecomplex * | x, | ||
| int_t | ldx | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zgeru_()
| void zgeru_ | ( | const int * | , |
| const int * | , | ||
| const doublecomplex * | , | ||
| const doublecomplex * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| const int * | , | ||
| doublecomplex * | , | ||
| const int * | |||
| ) |
Here is the caller graph for this function:
◆ zgetBigU()
| doublecomplex * zgetBigU | ( | superlu_dist_options_t * | , |
| int_t | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | |||
| ) |
◆ zgetBigV()
| doublecomplex * zgetBigV | ( | int_t | , |
| int_t | |||
| ) |
◆ zgsequ_dist()
| void zgsequ_dist | ( | SuperMatrix * | A, |
| double * | r, | ||
| double * | c, | ||
| double * | rowcnd, | ||
| double * | colcnd, | ||
| double * | amax, | ||
| int * | info | ||
| ) |
Purpose ======= ZGSEQU_DIST computes row and column scalings intended to equilibrate an M-by-N sparse matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. See supermatrix.h for the definition of 'SuperMatrix' structure. Arguments ========= A (input) SuperMatrix* The matrix of dimension (A->nrow, A->ncol) whose equilibration factors are to be computed. The type of A can be: Stype = SLU_NC; Dtype = SLU_Z; Mtype = SLU_GE. R (output) double*, size A->nrow If INFO = 0 or INFO > M, R contains the row scale factors for A. C (output) double*, size A->ncol If INFO = 0, C contains the column scale factors for A. ROWCND (output) double* If INFO = 0 or INFO > M, ROWCND contains the ratio of the smallest R(i) to the largest R(i). If ROWCND >= 0.1 and AMAX is neither too large nor too small, it is not worth scaling by R. COLCND (output) double* If INFO = 0, COLCND contains the ratio of the smallest C(i) to the largest C(i). If COLCND >= 0.1, it is not worth scaling by C. AMAX (output) double* Absolute value of largest matrix element. If AMAX is very close to overflow or very close to underflow, the matrix should be scaled. INFO (output) int* = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, and i is <= A->nrow: the i-th row of A is exactly zero > A->ncol: the (i-M)-th column of A is exactly zero =====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zgstrf2()
| void zgstrf2 | ( | int_t | k, |
| doublecomplex * | diagBlk, | ||
| int_t | LDA, | ||
| doublecomplex * | BlockUfactor, | ||
| int_t | LDU, | ||
| double | thresh, | ||
| int_t * | xsup, | ||
| superlu_dist_options_t * | options, | ||
| SuperLUStat_t * | stat, | ||
| int * | info | ||
| ) |
Here is the call graph for this function:
◆ zIBcast_LPanel()
| int_t zIBcast_LPanel | ( | int_t | k, |
| int_t | k0, | ||
| int_t * | lsub, | ||
| doublecomplex * | lusup, | ||
| gridinfo_t * | , | ||
| int * | msgcnt, | ||
| MPI_Request * | , | ||
| int ** | ToSendR, | ||
| int_t * | xsup, | ||
| int | |||
| ) |
◆ zIBcast_UPanel()
| int_t zIBcast_UPanel | ( | int_t | k, |
| int_t | k0, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| gridinfo_t * | , | ||
| int * | msgcnt, | ||
| MPI_Request * | , | ||
| int * | ToSendD, | ||
| int | |||
| ) |
◆ zIBcastRecvLPanel()
| int_t zIBcastRecvLPanel | ( | int_t | k, |
| int_t | k0, | ||
| int * | msgcnt, | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| int_t * | Lsub_buf, | ||
| doublecomplex * | Lval_buf, | ||
| int * | factored, | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SCT_t * | , | ||
| int | tag_ub | ||
| ) |
◆ zIBcastRecvUPanel()
| int_t zIBcastRecvUPanel | ( | int_t | k, |
| int_t | k0, | ||
| int * | msgcnt, | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| int_t * | Usub_buf, | ||
| doublecomplex * | Uval_buf, | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SCT_t * | , | ||
| int | tag_ub | ||
| ) |
◆ ziBcastXk2Pck()
| int_t ziBcastXk2Pck | ( | int_t | k, |
| doublecomplex * | x, | ||
| int | nrhs, | ||
| int ** | sendList, | ||
| MPI_Request * | send_req, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the caller graph for this function:
◆ zinf_norm_error_dist()
| void zinf_norm_error_dist | ( | int_t | n, |
| int_t | nrhs, | ||
| doublecomplex * | x, | ||
| int_t | ldx, | ||
| doublecomplex * | xtrue, | ||
| int_t | ldxtrue, | ||
| gridinfo_t * | grid | ||
| ) |
Check the inf-norm of the error vector.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zinit3DLUstruct()
| int_t zinit3DLUstruct | ( | int_t * | myTreeIdxs, |
| int_t * | myZeroTrIdxs, | ||
| int_t * | nodeCount, | ||
| int_t ** | nodeList, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zinit3DLUstructForest()
| void zinit3DLUstructForest | ( | int_t * | myTreeIdxs, |
| int_t * | myZeroTrIdxs, | ||
| sForest_t ** | sForests, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the caller graph for this function:
◆ zInit_HyP()
| void zInit_HyP | ( | superlu_dist_options_t * | , |
| HyP_t * | HyP, | ||
| zLocalLU_t * | Llu, | ||
| int_t | mcb, | ||
| int_t | mrb | ||
| ) |
Here is the caller graph for this function:
◆ zinitDiagFactBufs()
| int zinitDiagFactBufs | ( | int | ldt, |
| zdiagFactBufs_t * | dFBuf | ||
| ) |
Here is the caller graph for this function:
◆ zinitDiagFactBufsArr()
| zdiagFactBufs_t ** zinitDiagFactBufsArr | ( | int | mxLeafNode, |
| int | ldt, | ||
| gridinfo_t * | grid | ||
| ) |
◆ zinitDiagFactBufsArrMod()
| zdiagFactBufs_t ** zinitDiagFactBufsArrMod | ( | int | mxLeafNode, |
| int * | ldts, | ||
| gridinfo_t * | grid | ||
| ) |
Here is the caller graph for this function:
◆ zinitLsumBmod_buff()
| int_t zinitLsumBmod_buff | ( | int_t | ns, |
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf | ||
| ) |
Here is the caller graph for this function:
◆ zinitScuBufs()
| int_t zinitScuBufs | ( | superlu_dist_options_t * | , |
| int_t | ldt, | ||
| int_t | num_threads, | ||
| int_t | nsupers, | ||
| zscuBufs_t * | , | ||
| zLUstruct_t * | , | ||
| gridinfo_t * | |||
| ) |
Here is the caller graph for this function:
◆ zinitTrf3Dpartition()
| ztrf3Dpartition_t * zinitTrf3Dpartition | ( | int_t | nsupers, |
| superlu_dist_options_t * | options, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zinitTrf3Dpartition_allgrid()
| ztrf3Dpartition_t * zinitTrf3Dpartition_allgrid | ( | int_t | n, |
| superlu_dist_options_t * | options, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zinitTrf3DpartitionLUstructgrid0()
| ztrf3Dpartition_t * zinitTrf3DpartitionLUstructgrid0 | ( | int_t | n, |
| superlu_dist_options_t * | options, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zIRecv_LDiagBlock()
| int_t zIRecv_LDiagBlock | ( | int_t | k0, |
| doublecomplex * | L_blk_ptr, | ||
| int_t | size, | ||
| int_t | src, | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| SCT_t * | , | ||
| int | |||
| ) |
◆ zIrecv_LPanel()
| int_t zIrecv_LPanel | ( | int_t | k, |
| int_t | k0, | ||
| int_t * | Lsub_buf, | ||
| doublecomplex * | Lval_buf, | ||
| gridinfo_t * | , | ||
| MPI_Request * | , | ||
| zLocalLU_t * | , | ||
| int | |||
| ) |
◆ zIRecv_UDiagBlock()
| int_t zIRecv_UDiagBlock | ( | int_t | k0, |
| doublecomplex * | ublk_ptr, | ||
| int_t | size, | ||
| int_t | src, | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| SCT_t * | , | ||
| int | |||
| ) |
◆ zIrecv_UPanel()
| int_t zIrecv_UPanel | ( | int_t | k, |
| int_t | k0, | ||
| int_t * | Usub_buf, | ||
| doublecomplex * | , | ||
| zLocalLU_t * | , | ||
| gridinfo_t * | , | ||
| MPI_Request * | , | ||
| int | |||
| ) |
◆ zISend_LDiagBlock()
| int_t zISend_LDiagBlock | ( | int_t | k0, |
| doublecomplex * | lblk_ptr, | ||
| int_t | size, | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| int | |||
| ) |
◆ zISend_UDiagBlock()
| int_t zISend_UDiagBlock | ( | int_t | k0, |
| doublecomplex * | ublk_ptr, | ||
| int_t | size, | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| int | |||
| ) |
Here is the caller graph for this function:
◆ zlangs_dist()
| double zlangs_dist | ( | char * | norm, |
| SuperMatrix * | A | ||
| ) |
Purpose
=======
ZLANGS_DIST returns the value of the one norm, or the Frobenius norm, or
the infinity norm, or the element of largest absolute value of a
real matrix A.
Description
===========
ZLANGE returns the value
ZLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'
(
( norm1(A), NORM = '1', 'O' or 'o'
(
( normI(A), NORM = 'I' or 'i'
(
( normF(A), NORM = 'F', 'f', 'E' or 'e'
where norm1 denotes the one norm of a matrix (maximum column sum),
normI denotes the infinity norm of a matrix (maximum row sum) and
normF denotes the Frobenius norm of a matrix (square root of sum of
squares). Note that max(abs(A(i,j))) is not a matrix norm.
Arguments
=========
NORM (input) CHARACTER*1
Specifies the value to be returned in ZLANGE as described above.
A (input) SuperMatrix*
The M by N sparse matrix A.
=====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlaqgs_dist()
| void zlaqgs_dist | ( | SuperMatrix * | A, |
| double * | r, | ||
| double * | c, | ||
| double | rowcnd, | ||
| double | colcnd, | ||
| double | amax, | ||
| char * | equed | ||
| ) |
Purpose ======= ZLAQGS_DIST equilibrates a general sparse M by N matrix A using the row and scaling factors in the vectors R and C. See supermatrix.h for the definition of 'SuperMatrix' structure. Arguments ========= A (input/output) SuperMatrix* On exit, the equilibrated matrix. See EQUED for the form of the equilibrated matrix. The type of A can be: Stype = NC; Dtype = SLU_Z; Mtype = GE. R (input) double*, dimension (A->nrow) The row scale factors for A. C (input) double*, dimension (A->ncol) The column scale factors for A. ROWCND (input) double Ratio of the smallest R(i) to the largest R(i). COLCND (input) double Ratio of the smallest C(i) to the largest C(i). AMAX (input) double Absolute value of largest matrix entry. EQUED (output) char* Specifies the form of equilibration that was done. = 'N': No equilibration = 'R': Row equilibration, i.e., A has been premultiplied by diag(R). = 'C': Column equilibration, i.e., A has been postmultiplied by diag(C). = 'B': Both row and column equilibration, i.e., A has been replaced by diag(R) * A * diag(C). Internal Parameters =================== THRESH is a threshold value used to decide if row or column scaling should be done based on the ratio of the row or column scaling factors. If ROWCND < THRESH, row scaling is done, and if COLCND < THRESH, column scaling is done. LARGE and SMALL are threshold values used to decide if row scaling should be done based on the absolute size of the largest matrix element. If AMAX > LARGE or AMAX < SMALL, row scaling is done. =====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlasum_bmod_Tree()
| int_t zlasum_bmod_Tree | ( | int_t | pTree, |
| int_t | cTree, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | x, | ||
| zxT_struct * | xT_s, | ||
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf, | ||
| zLUstruct_t * | LUstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zldperm_dist()
| int zldperm_dist | ( | int | job, |
| int | n, | ||
| int_t | nnz, | ||
| int_t | colptr[], | ||
| int_t | adjncy[], | ||
| doublecomplex | nzval[], | ||
| int_t * | perm, | ||
| double | u[], | ||
| double | v[] | ||
| ) |
Purpose
=======
ZLDPERM finds a row permutation so that the matrix has large
entries on the diagonal.
Arguments
=========
job (input) int
Control the action. Possible values for JOB are:
= 1 : Compute a row permutation of the matrix so that the
permuted matrix has as many entries on its diagonal as
possible. The values on the diagonal are of arbitrary size.
HSL subroutine MC21A/AD is used for this.
= 2 : Compute a row permutation of the matrix so that the smallest
value on the diagonal of the permuted matrix is maximized.
= 3 : Compute a row permutation of the matrix so that the smallest
value on the diagonal of the permuted matrix is maximized.
The algorithm differs from the one used for JOB = 2 and may
have quite a different performance.
= 4 : Compute a row permutation of the matrix so that the sum
of the diagonal entries of the permuted matrix is maximized.
= 5 : Compute a row permutation of the matrix so that the product
of the diagonal entries of the permuted matrix is maximized
and vectors to scale the matrix so that the nonzero diagonal
entries of the permuted matrix are one in absolute value and
all the off-diagonal entries are less than or equal to one in
absolute value.
Restriction: 1 <= JOB <= 5.
n (input) int
The order of the matrix.
nnz (input) int
The number of nonzeros in the matrix.
adjncy (input) int*, of size nnz
The adjacency structure of the matrix, which contains the row
indices of the nonzeros.
colptr (input) int*, of size n+1
The pointers to the beginning of each column in ADJNCY.
nzval (input) doublecomplex*, of size nnz
The nonzero values of the matrix. nzval[k] is the value of
the entry corresponding to adjncy[k].
It is not used if job = 1.
perm (output) int*, of size n
The permutation vector. perm[i] = j means row i in the
original matrix is in row j of the permuted matrix.
u (output) double*, of size n
If job = 5, the natural logarithms of the row scaling factors.
v (output) double*, of size n
If job = 5, the natural logarithms of the column scaling factors.
The scaled matrix B has entries b_ij = a_ij * exp(u_i + v_j).
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zleafForestBackSolve3d()
| int_t zleafForestBackSolve3d | ( | superlu_dist_options_t * | options, |
| int_t | treeId, | ||
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | recvbuf, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zleafForestForwardSolve3d()
| int_t zleafForestForwardSolve3d | ( | superlu_dist_options_t * | options, |
| int_t | treeId, | ||
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | recvbuf, | ||
| doublecomplex * | rtemp, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zLluBufFreeArr()
| int zLluBufFreeArr | ( | int_t | numLA, |
| zLUValSubBuf_t ** | LUvsbs | ||
| ) |
Here is the caller graph for this function:
◆ zLluBufInit()
| int_t zLluBufInit | ( | zLUValSubBuf_t * | , |
| zLUstruct_t * | |||
| ) |
Here is the caller graph for this function:
◆ zLluBufInitArr()
| zLUValSubBuf_t ** zLluBufInitArr | ( | int_t | numLA, |
| zLUstruct_t * | LUstruct | ||
| ) |
Here is the caller graph for this function:
◆ zlocalSolveXkYk()
| int_t zlocalSolveXkYk | ( | trtype_t | trtype, |
| int_t | k, | ||
| doublecomplex * | x, | ||
| int | nrhs, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zLPanelTrSolve()
| int_t zLPanelTrSolve | ( | int_t | k, |
| int * | factored_L, | ||
| doublecomplex * | BlockUFactor, | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | |||
| ) |
◆ zLPanelUpdate()
| int_t zLPanelUpdate | ( | int_t | k, |
| int * | IrecvPlcd_D, | ||
| int * | factored_L, | ||
| MPI_Request * | , | ||
| doublecomplex * | BlockUFactor, | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SCT_t * | |||
| ) |
◆ zLpanelUpdate()
| int_t zLpanelUpdate | ( | int_t | off0, |
| int_t | nsupc, | ||
| doublecomplex * | ublk_ptr, | ||
| int_t | ld_ujrow, | ||
| doublecomplex * | lusup, | ||
| int_t | nsupr, | ||
| SCT_t * | |||
| ) |
◆ zlsum_bmod()
| void zlsum_bmod | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| int | nrhs, | ||
| int_t | k, | ||
| int * | bmod, | ||
| int_t * | Urbs, | ||
| Ucb_indptr_t ** | Ucb_indptr, | ||
| int_t ** | Ucb_valptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request | send_req[], | ||
| SuperLUStat_t * | stat | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_bmod_GG()
| void zlsum_bmod_GG | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf, | ||
| int_t | k, | ||
| int * | bmod, | ||
| int_t * | Urbs, | ||
| Ucb_indptr_t ** | Ucb_indptr, | ||
| int_t ** | Ucb_valptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request | send_req[], | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_bmod_GG_newsolve()
| void zlsum_bmod_GG_newsolve | ( | ztrf3Dpartition_t * | trf3Dpartition, |
| doublecomplex * | lsum, | ||
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf, | ||
| int_t | k, | ||
| int * | bmod, | ||
| int_t * | Urbs, | ||
| Ucb_indptr_t ** | Ucb_indptr, | ||
| int_t ** | Ucb_valptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request | send_req[], | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_bmod_inv()
| void zlsum_bmod_inv | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int_t | k, | ||
| int * | bmod, | ||
| int_t * | Urbs, | ||
| Ucb_indptr_t ** | Ucb_indptr, | ||
| int_t ** | Ucb_valptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| SuperLUStat_t ** | stat, | ||
| int_t * | root_send, | ||
| int_t * | nroot_send, | ||
| int_t | sizelsum, | ||
| int_t | sizertemp, | ||
| int | thread_id, | ||
| int | num_thread | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_bmod_inv_gpu_wrap()
| void zlsum_bmod_inv_gpu_wrap | ( | superlu_dist_options_t * | , |
| int | , | ||
| int | , | ||
| int | , | ||
| int | , | ||
| doublecomplex * | , | ||
| doublecomplex * | , | ||
| int | , | ||
| int | , | ||
| int_t | , | ||
| int * | , | ||
| C_Tree * | , | ||
| C_Tree * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int64_t * | , | ||
| int_t * | , | ||
| int64_t * | , | ||
| int_t * | , | ||
| int64_t * | , | ||
| doublecomplex * | , | ||
| int64_t * | , | ||
| doublecomplex * | , | ||
| int64_t * | , | ||
| doublecomplex * | , | ||
| int64_t * | , | ||
| int_t * | , | ||
| int64_t * | , | ||
| int_t * | , | ||
| gridinfo_t * | , | ||
| int_t | , | ||
| uint64_t * | , | ||
| uint64_t * | , | ||
| doublecomplex * | , | ||
| doublecomplex * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int | |||
| ) |
Here is the caller graph for this function:
◆ zlsum_bmod_inv_master()
| void zlsum_bmod_inv_master | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int_t | k, | ||
| int * | bmod, | ||
| int_t * | Urbs, | ||
| Ucb_indptr_t ** | Ucb_indptr, | ||
| int_t ** | Ucb_valptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| SuperLUStat_t ** | stat, | ||
| int_t | sizelsum, | ||
| int_t | sizertemp, | ||
| int | thread_id, | ||
| int | num_thread | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_fmod()
| void zlsum_fmod | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int | knsupc, | ||
| int_t | k, | ||
| int * | fmod, | ||
| int_t | nlb, | ||
| int_t | lptr, | ||
| int_t | luptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request | send_req[], | ||
| SuperLUStat_t * | stat | ||
| ) |
Purpose ======= Perform local block modifications: lsum[i] -= L_i,k * X[k].
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_fmod_inv()
| void zlsum_fmod_inv | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int_t | k, | ||
| int * | fmod, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| SuperLUStat_t ** | stat, | ||
| int_t * | leaf_send, | ||
| int_t * | nleaf_send, | ||
| int_t | sizelsum, | ||
| int_t | sizertemp, | ||
| int_t | recurlevel, | ||
| int_t | maxsuper, | ||
| int | thread_id, | ||
| int | num_thread | ||
| ) |
Purpose ======= Perform local block modifications: lsum[i] -= L_i,k * X[k].
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_fmod_inv_gpu_wrap()
| void zlsum_fmod_inv_gpu_wrap | ( | int | , |
| int | , | ||
| int | , | ||
| int | , | ||
| doublecomplex * | , | ||
| doublecomplex * | , | ||
| int | , | ||
| int | , | ||
| int_t | , | ||
| int * | fmod, | ||
| C_Tree * | , | ||
| C_Tree * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int64_t * | , | ||
| doublecomplex * | , | ||
| int64_t * | , | ||
| doublecomplex * | , | ||
| int64_t * | , | ||
| int_t * | , | ||
| int64_t * | , | ||
| int_t * | , | ||
| int * | , | ||
| gridinfo_t * | , | ||
| int_t | , | ||
| uint64_t * | , | ||
| uint64_t * | , | ||
| doublecomplex * | , | ||
| doublecomplex * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int * | , | ||
| int | |||
| ) |
Here is the caller graph for this function:
◆ zlsum_fmod_inv_master()
| void zlsum_fmod_inv_master | ( | doublecomplex * | lsum, |
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int | knsupc, | ||
| int_t | k, | ||
| int * | fmod, | ||
| int_t | nlb, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| SuperLUStat_t ** | stat, | ||
| int_t | sizelsum, | ||
| int_t | sizertemp, | ||
| int_t | recurlevel, | ||
| int_t | maxsuper, | ||
| int | thread_id, | ||
| int | num_thread | ||
| ) |
Purpose ======= Perform local block modifications: lsum[i] -= L_i,k * X[k].
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_fmod_leaf()
| void zlsum_fmod_leaf | ( | int_t | treeId, |
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int | knsupc, | ||
| int_t | k, | ||
| int * | fmod, | ||
| int_t | nlb, | ||
| int_t | lptr, | ||
| int_t | luptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request | send_req[], | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsum_fmod_leaf_newsolve()
| void zlsum_fmod_leaf_newsolve | ( | ztrf3Dpartition_t * | trf3Dpartition, |
| doublecomplex * | lsum, | ||
| doublecomplex * | x, | ||
| doublecomplex * | xk, | ||
| doublecomplex * | rtemp, | ||
| int | nrhs, | ||
| int | knsupc, | ||
| int_t | k, | ||
| int * | fmod, | ||
| int_t | nlb, | ||
| int_t | lptr, | ||
| int_t | luptr, | ||
| int_t * | xsup, | ||
| gridinfo_t * | grid, | ||
| zLocalLU_t * | Llu, | ||
| MPI_Request | send_req[], | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsumForestBsolve()
| int_t zlsumForestBsolve | ( | int_t | k, |
| int_t | treeId, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | x, | ||
| zxT_struct * | xT_s, | ||
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf, | ||
| zLUstruct_t * | LUstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zlsumReducePrK()
| int_t zlsumReducePrK | ( | int_t | k, |
| doublecomplex * | x, | ||
| doublecomplex * | lsum, | ||
| doublecomplex * | recvbuf, | ||
| int | nrhs, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the caller graph for this function:
◆ zLUstructFree()
| void zLUstructFree | ( | zLUstruct_t * | LUstruct | ) |
Deallocate LUstruct.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zLUstructInit()
| void zLUstructInit | ( | const | int_t, |
| zLUstruct_t * | LUstruct | ||
| ) |
Allocate storage in LUstruct.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zMaxAbsLij()
| double zMaxAbsLij | ( | int | iam, |
| int | n, | ||
| Glu_persist_t * | Glu_persist, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid | ||
| ) |
◆ zMaxAbsUij()
| double zMaxAbsUij | ( | int | iam, |
| int | n, | ||
| Glu_persist_t * | Glu_persist, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid | ||
| ) |
◆ znewTrfPartitionInit()
| void znewTrfPartitionInit | ( | int_t | nsupers, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ znonLeafForestBackSolve3d()
| int_t znonLeafForestBackSolve3d | ( | int_t | treeId, |
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x, | ||
| doublecomplex * | lsum, | ||
| zxT_struct * | xT_s, | ||
| doublecomplex * | recvbuf, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zlsumBmod_buff_t * | lbmod_buf, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Pkk(Yk) = sumOver_PrK (Yk)
Here is the call graph for this function:
Here is the caller graph for this function:
◆ znonLeafForestForwardSolve3d()
| int_t znonLeafForestForwardSolve3d | ( | int_t | treeId, |
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | x, | ||
| doublecomplex * | lsum, | ||
| zxT_struct * | xT_s, | ||
| doublecomplex * | recvbuf, | ||
| doublecomplex * | rtemp, | ||
| MPI_Request * | send_req, | ||
| int | nrhs, | ||
| zSOLVEstruct_t * | SOLVEstruct, | ||
| SuperLUStat_t * | stat, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Pkk(Yk) = sumOver_PrK (Yk)
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zp2pSolvedX3d()
| int_t zp2pSolvedX3d | ( | int_t | treeId, |
| int_t | sender, | ||
| int_t | receiver, | ||
| doublecomplex * | x, | ||
| int | nrhs, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the caller graph for this function:
◆ zp3dCollect()
| int_t zp3dCollect | ( | int_t | layer, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
◆ zp3dScatter()
| int_t zp3dScatter | ( | int_t | n, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| int * | supernodeMask | ||
| ) |
◆ zPackLBlock()
| int_t zPackLBlock | ( | int_t | k, |
| doublecomplex * | Dest, | ||
| Glu_persist_t * | , | ||
| gridinfo_t * | , | ||
| zLocalLU_t * | |||
| ) |
◆ zperform_row_permutation()
| void zperform_row_permutation | ( | superlu_dist_options_t * | options, |
| fact_t | Fact, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| zLUstruct_t * | LUstruct, | ||
| int_t | m, | ||
| int_t | n, | ||
| gridinfo_t * | grid, | ||
| SuperMatrix * | A, | ||
| SuperMatrix * | GA, | ||
| SuperLUStat_t * | stat, | ||
| int | job, | ||
| int | Equil, | ||
| int * | rowequ, | ||
| int * | colequ, | ||
| int * | iinfo | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zpivot_batch()
| int zpivot_batch | ( | superlu_dist_options_t * | options, |
| int | batchCount, | ||
| int | m, | ||
| int | n, | ||
| handle_t * | SparseMatrix_handles, | ||
| double ** | ReqPtr, | ||
| double ** | CeqPtr, | ||
| DiagScale_t * | DiagScale, | ||
| int ** | RpivPtr | ||
| ) |
Compute row pivotings for each matrix, for numerical stability.
- Parameters
-
[in] options solver options [in] batchCount number of matrices in the batch [in] m row dimension of the matrices [in] n column dimension of the matrices [in,out] SparseMatrix_handles pointers to the matrices in the batch, each pointing to the actual stoage in CSC format On entry, the original matrices, may be overwritten by A1 <- diag(R)*A*diag(C) from dequil_batch() On exit, each matrix may be A2 <- Pr*A1 [in,out] ReqPtr pointers to row scaling vectors, maybe overwritten by scaling from MC64 [in,out] CeqPtr pointers to column scaling vectors, maybe overwritten by scaling from MC64 [in,out] DiagScale array indicating how each system is equilibrated: {ROW, COL, BOTH} [in,out] RpivPtr pointers to row permutation vectors for each matrix, each of size m On exit, each RpivPtr[] is applied to each matrix Return value: 0, success -1, invalid RowPerm option; an Identity perm_r[] is returned d, indicates that the d-th matrix is the first one in the batch encountering error
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zprepare_multiGPU_buffers()
| void zprepare_multiGPU_buffers | ( | int | , |
| int | , | ||
| int | , | ||
| int | , | ||
| int | , | ||
| int | |||
| ) |
Here is the caller graph for this function:
◆ zPrint_CompCol_Matrix_dist()
| void zPrint_CompCol_Matrix_dist | ( | SuperMatrix * | ) |
Here is the caller graph for this function:
◆ zPrint_CompRowLoc_Matrix_dist()
| int zPrint_CompRowLoc_Matrix_dist | ( | SuperMatrix * | ) |
◆ zPrint_Dense_Matrix_dist()
| void zPrint_Dense_Matrix_dist | ( | SuperMatrix * | ) |
◆ zPrintLblocks()
| void zPrintLblocks | ( | int | iam, |
| int_t | nsupers, | ||
| gridinfo_t * | grid, | ||
| Glu_persist_t * | Glu_persist, | ||
| zLocalLU_t * | Llu | ||
| ) |
Print the blocks in the factored matrix L.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zPrintUblocks()
| void zPrintUblocks | ( | int | iam, |
| int_t | nsupers, | ||
| gridinfo_t * | grid, | ||
| Glu_persist_t * | Glu_persist, | ||
| zLocalLU_t * | Llu | ||
| ) |
Print the blocks in the factored matrix U.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zQuerySpace_dist()
| int_t zQuerySpace_dist | ( | int_t | n, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat, | ||
| superlu_dist_mem_usage_t * | mem_usage | ||
| ) |
mem_usage consists of the following fields:
- for_lu (float) The amount of space used in bytes for the L\U data structures.
- total (float) The amount of space needed in bytes to perform factorization.
- expansions (int) Number of memory expansions during the LU factorization.
Here is the caller graph for this function:
◆ zread_binary()
| int zread_binary | ( | FILE * | fp, |
| int_t * | m, | ||
| int_t * | n, | ||
| int_t * | nnz, | ||
| doublecomplex ** | nzval, | ||
| int_t ** | rowind, | ||
| int_t ** | colptr | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zreadhb_dist()
| void zreadhb_dist | ( | int | iam, |
| FILE * | fp, | ||
| int_t * | nrow, | ||
| int_t * | ncol, | ||
| int_t * | nonz, | ||
| doublecomplex ** | nzval, | ||
| int_t ** | rowind, | ||
| int_t ** | colptr | ||
| ) |
Purpose
=======
Read a DOUBLE COMPLEX PRECISION matrix stored in Harwell-Boeing format
as described below.
Line 1 (A72,A8)
Col. 1 - 72 Title (TITLE)
Col. 73 - 80 Key (KEY)
Line 2 (5I14)
Col. 1 - 14 Total number of lines excluding header (TOTCRD)
Col. 15 - 28 Number of lines for pointers (PTRCRD)
Col. 29 - 42 Number of lines for row (or variable) indices (INDCRD)
Col. 43 - 56 Number of lines for numerical values (VALCRD)
Col. 57 - 70 Number of lines for right-hand sides (RHSCRD)
(including starting guesses and solution vectors
if present)
(zero indicates no right-hand side data is present)
Line 3 (A3, 11X, 4I14)
Col. 1 - 3 Matrix type (see below) (MXTYPE)
Col. 15 - 28 Number of rows (or variables) (NROW)
Col. 29 - 42 Number of columns (or elements) (NCOL)
Col. 43 - 56 Number of row (or variable) indices (NNZERO)
(equal to number of entries for assembled matrices)
Col. 57 - 70 Number of elemental matrix entries (NELTVL)
(zero in the case of assembled matrices)
Line 4 (2A16, 2A20)
Col. 1 - 16 Format for pointers (PTRFMT)
Col. 17 - 32 Format for row (or variable) indices (INDFMT)
Col. 33 - 52 Format for numerical values of coefficient matrix (VALFMT)
Col. 53 - 72 Format for numerical values of right-hand sides (RHSFMT)
Line 5 (A3, 11X, 2I14) Only present if there are right-hand sides present
Col. 1 Right-hand side type:
F for full storage or M for same format as matrix
Col. 2 G if a starting vector(s) (Guess) is supplied. (RHSTYP)
Col. 3 X if an exact solution vector(s) is supplied.
Col. 15 - 28 Number of right-hand sides (NRHS)
Col. 29 - 42 Number of row indices (NRHSIX)
(ignored in case of unassembled matrices)
The three character type field on line 3 describes the matrix type.
The following table lists the permitted values for each of the three
characters. As an example of the type field, RSA denotes that the matrix
is real, symmetric, and assembled.
First Character:
R Real matrix
C Complex matrix
P Pattern only (no numerical values supplied)
Second Character:
S Symmetric
U Unsymmetric
H Hermitian
Z Skew symmetric
R Rectangular
Third Character:
A Assembled
E Elemental matrices (unassembled)
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zreadMM_dist()
| void zreadMM_dist | ( | FILE * | fp, |
| int_t * | m, | ||
| int_t * | n, | ||
| int_t * | nonz, | ||
| doublecomplex ** | nzval, | ||
| int_t ** | rowind, | ||
| int_t ** | colptr | ||
| ) |
brief
Output parameters
=================
(nzval, rowind, colptr): (*rowind)[*] contains the row subscripts of
nonzeros in columns of matrix A; (*nzval)[*] the numerical values;
column i of A is given by (*nzval)[k], k = (*rowind)[i],...,
(*rowind)[i+1]-1.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zreadrb_dist()
| void zreadrb_dist | ( | int | iam, |
| FILE * | fp, | ||
| int_t * | nrow, | ||
| int_t * | ncol, | ||
| int_t * | nonz, | ||
| doublecomplex ** | nzval, | ||
| int_t ** | rowind, | ||
| int_t ** | colptr | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zreadtriple_dist()
| void zreadtriple_dist | ( | FILE * | fp, |
| int_t * | m, | ||
| int_t * | n, | ||
| int_t * | nonz, | ||
| doublecomplex ** | nzval, | ||
| int_t ** | rowind, | ||
| int_t ** | colptr | ||
| ) |
brief
Output parameters
=================
(nzval, rowind, colptr): (*rowind)[*] contains the row subscripts of
nonzeros in columns of matrix A; (*nzval)[*] the numerical values;
column i of A is given by (*nzval)[k], k = (*rowind)[i],...,
(*rowind)[i+1]-1.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zreadtriple_noheader()
| void zreadtriple_noheader | ( | FILE * | fp, |
| int_t * | m, | ||
| int_t * | n, | ||
| int_t * | nonz, | ||
| doublecomplex ** | nzval, | ||
| int_t ** | rowind, | ||
| int_t ** | colptr | ||
| ) |
brief
Output parameters
=================
(nzval, rowind, colptr): (*rowind)[*] contains the row subscripts of
nonzeros in columns of matrix A; (*nzval)[*] the numerical values;
column i of A is given by (*nzval)[k], k = (*rowind)[i],...,
(*rowind)[i+1]-1.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zRecv_UDiagBlock()
| int_t zRecv_UDiagBlock | ( | int_t | k0, |
| doublecomplex * | ublk_ptr, | ||
| int_t | size, | ||
| int_t | src, | ||
| gridinfo_t * | , | ||
| SCT_t * | , | ||
| int | |||
| ) |
Here is the caller graph for this function:
◆ zReDistribute_A()
| int_t zReDistribute_A | ( | SuperMatrix * | A, |
| zScalePermstruct_t * | ScalePermstruct, | ||
| Glu_freeable_t * | Glu_freeable, | ||
| int_t * | xsup, | ||
| int_t * | supno, | ||
| gridinfo_t * | grid, | ||
| int_t * | colptr[], | ||
| int_t * | rowind[], | ||
| doublecomplex * | a[] | ||
| ) |
Purpose
=======
Re-distribute A on the 2D process mesh.
Arguments
=========
A (input) SuperMatrix*
The distributed input matrix A of dimension (A->nrow, A->ncol).
A may be overwritten by diag(R)*A*diag(C)*Pc^T.
The type of A can be: Stype = SLU_NR_loc; Dtype = SLU_Z; Mtype = SLU_GE.
ScalePermstruct (input) zScalePermstruct_t*
The data structure to store the scaling and permutation vectors
describing the transformations performed to the original matrix A.
Glu_freeable (input) *Glu_freeable_t
The global structure describing the graph of L and U.
grid (input) gridinfo_t*
The 2D process mesh.
colptr (output) int*
rowind (output) int*
a (output) doublecomplex*
Return value
============
> 0, working storage (in bytes) required to perform redistribution.
(excluding LU factor size)
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zreduceAllAncestors3d()
| int zreduceAllAncestors3d | ( | int_t | ilvl, |
| int_t * | myNodeCount, | ||
| int_t ** | treePerm, | ||
| zLUValSubBuf_t * | LUvsb, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
Here is the caller graph for this function:
◆ zreduceAncestors3d()
| int_t zreduceAncestors3d | ( | int_t | sender, |
| int_t | receiver, | ||
| int_t | nnodes, | ||
| int_t * | nodeList, | ||
| doublecomplex * | Lval_buf, | ||
| doublecomplex * | Uval_buf, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
◆ zreduceSolvedX_newsolve()
| int_t zreduceSolvedX_newsolve | ( | int_t | treeId, |
| int_t | sender, | ||
| int_t | receiver, | ||
| doublecomplex * | x, | ||
| int | nrhs, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| doublecomplex * | recvbuf, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the caller graph for this function:
◆ zRgather_L()
| void zRgather_L | ( | int_t | k, |
| int_t * | lsub, | ||
| doublecomplex * | lusup, | ||
| gEtreeInfo_t * | , | ||
| Glu_persist_t * | , | ||
| gridinfo_t * | , | ||
| HyP_t * | , | ||
| int_t * | myIperm, | ||
| int_t * | iperm_c_supno | ||
| ) |
◆ zRgather_U()
| void zRgather_U | ( | int_t | k, |
| int_t | jj0, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| doublecomplex * | bigU, | ||
| gEtreeInfo_t * | , | ||
| Glu_persist_t * | , | ||
| gridinfo_t * | , | ||
| HyP_t * | , | ||
| int_t * | myIperm, | ||
| int_t * | iperm_c_supno, | ||
| int_t * | perm_u | ||
| ) |
◆ zscal_()
| int zscal_ | ( | const int * | n, |
| const doublecomplex * | alpha, | ||
| doublecomplex * | dx, | ||
| const int * | incx | ||
| ) |
◆ zScaleAdd_CompRowLoc_Matrix_dist()
| void zScaleAdd_CompRowLoc_Matrix_dist | ( | SuperMatrix * | A, |
| SuperMatrix * | B, | ||
| doublecomplex | c | ||
| ) |
Scale and add: adds a scalar multiple of one matrix to another. A_{i,j} = c * A_{i,j} + B_{i,j}$ for i,j=1,...,n.
◆ zScaleAddId_CompRowLoc_Matrix_dist()
| void zScaleAddId_CompRowLoc_Matrix_dist | ( | SuperMatrix * | A, |
| doublecomplex | c | ||
| ) |
Scale and add I: scales a matrix and adds an identity. A_{i,j} = c * A_{i,j} + \delta_{i,j} for i,j=1,...,n and \delta_{i,j} is the Kronecker delta.
Here is the call graph for this function:
◆ zscaleMatrixDiagonally()
| void zscaleMatrixDiagonally | ( | fact_t | Fact, |
| zScalePermstruct_t * | ScalePermstruct, | ||
| SuperMatrix * | A, | ||
| SuperLUStat_t * | stat, | ||
| gridinfo_t * | grid, | ||
| int * | rowequ, | ||
| int * | colequ, | ||
| int * | iinfo | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zScalePermstructFree()
| void zScalePermstructFree | ( | zScalePermstruct_t * | ScalePermstruct | ) |
Deallocate ScalePermstruct.
Here is the caller graph for this function:
◆ zScalePermstructInit()
| void zScalePermstructInit | ( | const | int_t, |
| const | int_t, | ||
| zScalePermstruct_t * | ScalePermstruct | ||
| ) |
Allocate storage in ScalePermstruct.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zscatter3dLPanels()
| int_t zscatter3dLPanels | ( | int_t | nsupers, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| int * | supernodeMask | ||
| ) |
◆ zscatter3dUPanels()
| int_t zscatter3dUPanels | ( | int_t | nsupers, |
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| int * | supernodeMask | ||
| ) |
◆ zScatter_B3d()
| int zScatter_B3d | ( | NRformat_loc3d * | A3d, |
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the caller graph for this function:
◆ zscatter_l()
| void zscatter_l | ( | int | ib, |
| int | ljb, | ||
| int | nsupc, | ||
| int_t | iukp, | ||
| int_t * | xsup, | ||
| int | klst, | ||
| int | nbrow, | ||
| int_t | lptr, | ||
| int | temp_nbrow, | ||
| int_t * | usub, | ||
| int_t * | lsub, | ||
| doublecomplex * | tempv, | ||
| int * | indirect_thread, | ||
| int * | indirect2, | ||
| int_t ** | Lrowind_bc_ptr, | ||
| doublecomplex ** | Lnzval_bc_ptr, | ||
| gridinfo_t * | grid | ||
| ) |
◆ zscatter_u()
| void zscatter_u | ( | int | ib, |
| int | jb, | ||
| int | nsupc, | ||
| int_t | iukp, | ||
| int_t * | xsup, | ||
| int | klst, | ||
| int | nbrow, | ||
| int_t | lptr, | ||
| int | temp_nbrow, | ||
| int_t * | lsub, | ||
| int_t * | usub, | ||
| doublecomplex * | tempv, | ||
| int_t ** | Ufstnz_br_ptr, | ||
| doublecomplex ** | Unzval_br_ptr, | ||
| gridinfo_t * | grid | ||
| ) |
◆ zSchurComplementSetup()
| int_t zSchurComplementSetup | ( | int_t | k, |
| int * | msgcnt, | ||
| Ublock_info_t * | , | ||
| Remain_info_t * | , | ||
| uPanelInfo_t * | , | ||
| lPanelInfo_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| doublecomplex * | bigU, | ||
| int_t * | Lsub_buf, | ||
| doublecomplex * | Lval_buf, | ||
| int_t * | Usub_buf, | ||
| doublecomplex * | Uval_buf, | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | |||
| ) |
◆ zSchurComplementSetupGPU()
| int_t zSchurComplementSetupGPU | ( | int_t | k, |
| msgs_t * | msgs, | ||
| packLUInfo_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| int_t * | , | ||
| gEtreeInfo_t * | , | ||
| factNodelists_t * | , | ||
| zscuBufs_t * | , | ||
| zLUValSubBuf_t * | LUvsb, | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| HyP_t * | |||
| ) |
◆ zSolveFinalize()
| void zSolveFinalize | ( | superlu_dist_options_t * | options, |
| zSOLVEstruct_t * | SOLVEstruct | ||
| ) |
Release the resources used for the solution phase.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zSolveInit()
| int zSolveInit | ( | superlu_dist_options_t * | options, |
| SuperMatrix * | A, | ||
| int_t | perm_r[], | ||
| int_t | perm_c[], | ||
| int_t | nrhs, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| zSOLVEstruct_t * | SOLVEstruct | ||
| ) |
Initialize the data structure for the solution phase.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zsparseTreeFactor()
| int_t zsparseTreeFactor | ( | int_t | nnodes, |
| int_t * | perm_c_supno, | ||
| treeTopoInfo_t * | treeTopoInfo, | ||
| commRequests_t * | comReqs, | ||
| zscuBufs_t * | scuBufs, | ||
| packLUInfo_t * | packLUInfo, | ||
| msgs_t * | msgs, | ||
| zLUValSubBuf_t * | LUvsb, | ||
| zdiagFactBufs_t * | dFBuf, | ||
| factStat_t * | factStat, | ||
| factNodelists_t * | fNlists, | ||
| superlu_dist_options_t * | options, | ||
| int_t * | gIperm_c_supno, | ||
| int_t | ldt, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat, | ||
| double | thresh, | ||
| SCT_t * | SCT, | ||
| int * | info | ||
| ) |
◆ zsparseTreeFactor_ASYNC()
| int_t zsparseTreeFactor_ASYNC | ( | sForest_t * | sforest, |
| commRequests_t ** | comReqss, | ||
| zscuBufs_t * | scuBufs, | ||
| packLUInfo_t * | packLUInfo, | ||
| msgs_t ** | msgss, | ||
| zLUValSubBuf_t ** | LUvsbs, | ||
| zdiagFactBufs_t ** | dFBufs, | ||
| factStat_t * | factStat, | ||
| factNodelists_t * | fNlists, | ||
| gEtreeInfo_t * | gEtreeInfo, | ||
| superlu_dist_options_t * | options, | ||
| int_t * | gIperm_c_supno, | ||
| int_t | ldt, | ||
| HyP_t * | HyP, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SuperLUStat_t * | stat, | ||
| double | thresh, | ||
| SCT_t * | SCT, | ||
| int | tag_ub, | ||
| int * | info | ||
| ) |
Here is the caller graph for this function:
◆ zstatic_schedule()
| int zstatic_schedule | ( | superlu_dist_options_t * | options, |
| int | m, | ||
| int | n, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat, | ||
| int_t * | perm_c_supno, | ||
| int_t * | iperm_c_supno, | ||
| int * | info | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zTrs2_GatherTrsmScatter()
| int_t zTrs2_GatherTrsmScatter | ( | int_t | klst, |
| int_t | iukp, | ||
| int_t | rukp, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| doublecomplex * | tempv, | ||
| int_t | knsupc, | ||
| int | nsupr, | ||
| doublecomplex * | lusup, | ||
| Glu_persist_t * | Glu_persist | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ zTrs2_GatherU()
| int_t zTrs2_GatherU | ( | int_t | iukp, |
| int_t | rukp, | ||
| int_t | klst, | ||
| int_t | nsupc, | ||
| int_t | ldu, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| doublecomplex * | tempv | ||
| ) |
Here is the caller graph for this function:
◆ zTrs2_ScatterU()
| int_t zTrs2_ScatterU | ( | int_t | iukp, |
| int_t | rukp, | ||
| int_t | klst, | ||
| int_t | nsupc, | ||
| int_t | ldu, | ||
| int_t * | usub, | ||
| doublecomplex * | uval, | ||
| doublecomplex * | tempv | ||
| ) |
Here is the caller graph for this function:
◆ ztrs_B_init3d()
| int_t ztrs_B_init3d | ( | int_t | nsupers, |
| doublecomplex * | x, | ||
| int | nrhs, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d | ||
| ) |
Here is the caller graph for this function:
◆ ztrs_compute_communication_structure()
| int ztrs_compute_communication_structure | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| zLUstruct_t * | LUstruct, | ||
| zScalePermstruct_t * | ScalePermstruct, | ||
| int * | supernodeMask, | ||
| gridinfo_t * | grid, | ||
| SuperLUStat_t * | stat | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ ztrs_X_gather3d()
| int_t ztrs_X_gather3d | ( | doublecomplex * | x, |
| int | nrhs, | ||
| ztrf3Dpartition_t * | trf3Dpartition, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| xtrsTimer_t * | xtrsTimer | ||
| ) |
Here is the call graph for this function:
Here is the caller graph for this function:
◆ ztrsm_()
| int ztrsm_ | ( | const char * | , |
| const char * | , | ||
| const char * | , | ||
| const char * | , | ||
| const int * | , | ||
| const int * | , | ||
| const doublecomplex * | , | ||
| const doublecomplex * | , | ||
| const int * | , | ||
| doublecomplex * | , | ||
| const int * | |||
| ) |
Here is the caller graph for this function:
◆ ztrsv_()
| int ztrsv_ | ( | char * | , |
| char * | , | ||
| char * | , | ||
| int * | , | ||
| doublecomplex * | , | ||
| int * | , | ||
| doublecomplex * | , | ||
| int * | |||
| ) |
Here is the caller graph for this function:
◆ ztrtri_()
| void ztrtri_ | ( | char * | , |
| char * | , | ||
| int * | , | ||
| doublecomplex * | , | ||
| int * | , | ||
| int * | |||
| ) |
Here is the caller graph for this function:
◆ zUDiagBlockRecvWait()
| int_t zUDiagBlockRecvWait | ( | int_t | k, |
| int * | IrecvPlcd_D, | ||
| int * | factored_L, | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SCT_t * | |||
| ) |
◆ zUPanelTrSolve()
| int_t zUPanelTrSolve | ( | int_t | k, |
| doublecomplex * | BlockLFactor, | ||
| doublecomplex * | bigV, | ||
| int_t | ldt, | ||
| Ublock_info_t * | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SuperLUStat_t * | , | ||
| SCT_t * | |||
| ) |
◆ zUPanelUpdate()
| int_t zUPanelUpdate | ( | int_t | k, |
| int * | factored_U, | ||
| MPI_Request * | , | ||
| doublecomplex * | BlockLFactor, | ||
| doublecomplex * | bigV, | ||
| int_t | ldt, | ||
| Ublock_info_t * | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SuperLUStat_t * | , | ||
| SCT_t * | |||
| ) |
◆ zuser_free_dist()
◆ zuser_malloc_dist()
◆ zWait_LRecv()
| int_t zWait_LRecv | ( | MPI_Request * | , |
| int * | msgcnt, | ||
| int * | msgcntsU, | ||
| gridinfo_t * | , | ||
| SCT_t * | |||
| ) |
◆ zWait_URecv()
◆ zWaitL()
| int_t zWaitL | ( | int_t | k, |
| int * | msgcnt, | ||
| int * | msgcntU, | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SCT_t * | |||
| ) |
◆ zWaitU()
| int_t zWaitU | ( | int_t | k, |
| int * | msgcnt, | ||
| MPI_Request * | , | ||
| MPI_Request * | , | ||
| gridinfo_t * | , | ||
| zLUstruct_t * | , | ||
| SCT_t * | |||
| ) |
◆ zwriteLUtoDisk()
| int zwriteLUtoDisk | ( | int | nsupers, |
| int_t * | xsup, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Here is the caller graph for this function:
◆ zZero_CompRowLoc_Matrix_dist()
| void zZero_CompRowLoc_Matrix_dist | ( | SuperMatrix * | A | ) |
Sets all entries of a matrix to zero, A_{i,j}=0, for i,j=1,..,n.
Here is the call graph for this function:
◆ zZeroLblocks()
| void zZeroLblocks | ( | int | iam, |
| int | n, | ||
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Sets all entries of matrix L to zero.
Here is the caller graph for this function:
◆ zzeroSetLU()
| int_t zzeroSetLU | ( | int_t | nnodes, |
| int_t * | nodeList, | ||
| zLUstruct_t * | , | ||
| gridinfo3d_t * | |||
| ) |
◆ zZeroUblocks()
| void zZeroUblocks | ( | int | iam, |
| int | n, | ||
| gridinfo_t * | grid, | ||
| zLUstruct_t * | LUstruct | ||
| ) |
Sets all entries of matrix U to zero.
Here is the caller graph for this function:
◆ zzRecvLPanel()
| int_t zzRecvLPanel | ( | int_t | k, |
| int_t | sender, | ||
| doublecomplex | alpha, | ||
| doublecomplex | beta, | ||
| doublecomplex * | Lval_buf, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
◆ zzRecvUPanel()
| int_t zzRecvUPanel | ( | int_t | k, |
| int_t | sender, | ||
| doublecomplex | alpha, | ||
| doublecomplex | beta, | ||
| doublecomplex * | Uval_buf, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
◆ zzSendLPanel()
| int_t zzSendLPanel | ( | int_t | k, |
| int_t | receiver, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
◆ zzSendUPanel()
| int_t zzSendUPanel | ( | int_t | k, |
| int_t | receiver, | ||
| zLUstruct_t * | LUstruct, | ||
| gridinfo3d_t * | grid3d, | ||
| SCT_t * | SCT | ||
| ) |
Variable Documentation
◆ zready_lsum
|
extern |
◆ zready_x
|
extern |
