superlu_sdefs.h File Reference

Distributed SuperLU data types and function prototypes. More...

#include "superlu_defs.h"

Include dependency graph for superlu_sdefs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	sScalePermstruct_t
struct	sLocalLU_t
struct	sLUstruct_t
struct	psgsmv_comm_t
struct	sSOLVEstruct_t
struct	uPanelInfo_t
struct	lPanelInfo_t
struct	HyP_t
struct	sLUValSubBuf_t
struct	trf3Dpartition_t
struct	sscuBufs_t
struct	sdiagFactBufs_t
struct	packLUInfo_t

Macros
#define	MAX_LOOKAHEADS   50

Functions
int_t	scuStatUpdate (int_t knsupc, HyP_t *HyP, SCT_t *SCT, SuperLUStat_t *stat)
void	sCreate_CompCol_Matrix_dist (SuperMatrix *, int_t, int_t, int_t, float *, int_t *, int_t *, Stype_t, Dtype_t, Mtype_t)
void	sCreate_CompRowLoc_Matrix_dist (SuperMatrix *, int_t, int_t, int_t, int_t, int_t, float *, int_t *, int_t *, Stype_t, Dtype_t, Mtype_t)
void	sCompRow_to_CompCol_dist (int_t, int_t, int_t, float *, int_t *, int_t *, float **, int_t **, int_t **)
int	psCompRow_loc_to_CompCol_global (int_t, SuperMatrix *, gridinfo_t *, SuperMatrix *)
	Gather A from the distributed compressed row format to global A in compressed column format. More...
void	sCopy_CompCol_Matrix_dist (SuperMatrix *, SuperMatrix *)
void	sCreate_Dense_Matrix_dist (SuperMatrix *, int_t, int_t, float *, int_t, Stype_t, Dtype_t, Mtype_t)
void	sCreate_SuperNode_Matrix_dist (SuperMatrix *, int_t, int_t, int_t, float *, int_t *, int_t *, int_t *, int_t *, int_t *, Stype_t, Dtype_t, Mtype_t)
void	sCopy_Dense_Matrix_dist (int_t, int_t, float *, int_t, float *, int_t)
void	sallocateA_dist (int_t, int_t, float **, int_t **, int_t **)
void	sGenXtrue_dist (int_t, int_t, float *, int_t)
void	sFillRHS_dist (char *, int_t, float *, int_t, SuperMatrix *, float *, int_t)
	Let rhs[i] = sum of i-th row of A, so the solution vector is all 1's. More...
int	screate_matrix (SuperMatrix *, int, float **, int *, float **, int *, FILE *, gridinfo_t *)
int	screate_matrix_rb (SuperMatrix *, int, float **, int *, float **, int *, FILE *, gridinfo_t *)
int	screate_matrix_dat (SuperMatrix *, int, float **, int *, float **, int *, FILE *, gridinfo_t *)
int	screate_matrix_postfix (SuperMatrix *, int, float **, int *, float **, int *, FILE *, char *, gridinfo_t *)
void	sScalePermstructInit (const int_t, const int_t, sScalePermstruct_t *)
	Allocate storage in ScalePermstruct. More...
void	sScalePermstructFree (sScalePermstruct_t *)
	Deallocate ScalePermstruct. More...
void	sgsequ_dist (SuperMatrix *, float *, float *, float *, float *, float *, int_t *)
float	slangs_dist (char *, SuperMatrix *)
void	slaqgs_dist (SuperMatrix *, float *, float *, float, float, float, char *)
void	psgsequ (SuperMatrix *, float *, float *, float *, float *, float *, int_t *, gridinfo_t *)
float	pslangs (char *, SuperMatrix *, gridinfo_t *)
void	pslaqgs (SuperMatrix *, float *, float *, float, float, float, char *)
int	psPermute_Dense_Matrix (int_t, int_t, int_t[], int_t[], float[], int, float[], int, int, gridinfo_t *)
	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. More...
int	sp_strsv_dist (char *, char *, char *, SuperMatrix *, SuperMatrix *, float *, int *)
int	sp_sgemv_dist (char *, float, SuperMatrix *, float *, int, float, float *, int)
	SpGEMV. More...
int	sp_sgemm_dist (char *, int, float, SuperMatrix *, float *, int, float, float *, int)
float	sdistribute (fact_t, int_t, SuperMatrix *, Glu_freeable_t *, sLUstruct_t *, gridinfo_t *)
void	psgssvx_ABglobal (superlu_dist_options_t *, SuperMatrix *, sScalePermstruct_t *, float *, int, int, gridinfo_t *, sLUstruct_t *, float *, SuperLUStat_t *, int *)
float	psdistribute (fact_t, int_t, SuperMatrix *, sScalePermstruct_t *, Glu_freeable_t *, sLUstruct_t *, gridinfo_t *)
void	psgssvx (superlu_dist_options_t *, SuperMatrix *, sScalePermstruct_t *, float *, int, int, gridinfo_t *, sLUstruct_t *, sSOLVEstruct_t *, float *, SuperLUStat_t *, int *)
void	psCompute_Diag_Inv (int_t, sLUstruct_t *, gridinfo_t *, SuperLUStat_t *, int *)
int	sSolveInit (superlu_dist_options_t *, SuperMatrix *, int_t[], int_t[], int_t, sLUstruct_t *, gridinfo_t *, sSOLVEstruct_t *)
	Initialize the data structure for the solution phase. More...
void	sSolveFinalize (superlu_dist_options_t *, sSOLVEstruct_t *)
	Release the resources used for the solution phase. More...
void	sDestroy_A3d_gathered_on_2d (sSOLVEstruct_t *, gridinfo3d_t *)
int_t	psgstrs_init (int_t, int_t, int_t, int_t, int_t[], int_t[], gridinfo_t *grid, Glu_persist_t *, sSOLVEstruct_t *)
void	pxgstrs_finalize (pxgstrs_comm_t *)
int	sldperm_dist (int, int, int_t, int_t[], int_t[], float[], int_t *, float[], float[])
int	sstatic_schedule (superlu_dist_options_t *, int, int, sLUstruct_t *, gridinfo_t *, SuperLUStat_t *, int_t *, int_t *, int *)
void	sLUstructInit (const int_t, sLUstruct_t *)
	Allocate storage in LUstruct. More...
void	sLUstructFree (sLUstruct_t *)
	Deallocate LUstruct. More...
void	sDestroy_LU (int_t, gridinfo_t *, sLUstruct_t *)
	Destroy distributed L & U matrices. More...
void	sDestroy_Tree (int_t, gridinfo_t *, sLUstruct_t *)
	Destroy broadcast and reduction trees used in triangular solve. More...
void	sscatter_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, float *tempv, int *indirect_thread, int *indirect2, int_t **Lrowind_bc_ptr, float **Lnzval_bc_ptr, gridinfo_t *grid)
void	sscatter_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, float *tempv, int_t **Ufstnz_br_ptr, float **Unzval_br_ptr, gridinfo_t *grid)
int_t	psgstrf (superlu_dist_options_t *, int, int, float anorm, sLUstruct_t *, gridinfo_t *, SuperLUStat_t *, int *)
void	psgstrs_Bglobal (int_t, sLUstruct_t *, gridinfo_t *, float *, int_t, int, SuperLUStat_t *, int *)
void	psgstrs (int_t, sLUstruct_t *, sScalePermstruct_t *, gridinfo_t *, float *, int_t, int_t, int_t, int, sSOLVEstruct_t *, SuperLUStat_t *, int *)
void	psgstrf2_trsm (superlu_dist_options_t *options, int_t k0, int_t k, double thresh, Glu_persist_t *, gridinfo_t *, sLocalLU_t *, MPI_Request *, int tag_ub, SuperLUStat_t *, int *info)
void	psgstrs2_omp (int_t k0, int_t k, Glu_persist_t *, gridinfo_t *, sLocalLU_t *, Ublock_info_t *, SuperLUStat_t *)
int_t	psReDistribute_B_to_X (float *B, int_t m_loc, int nrhs, int_t ldb, int_t fst_row, int_t *ilsum, float *x, sScalePermstruct_t *, Glu_persist_t *, gridinfo_t *, sSOLVEstruct_t *)
void	slsum_fmod (float *, float *, float *, float *, int, int, int_t, int *fmod, int_t, int_t, int_t, int_t *, gridinfo_t *, sLocalLU_t *, MPI_Request[], SuperLUStat_t *)
void	slsum_bmod (float *, float *, float *, int, int_t, int *bmod, int_t *, Ucb_indptr_t **, int_t **, int_t *, gridinfo_t *, sLocalLU_t *, MPI_Request[], SuperLUStat_t *)
void	slsum_fmod_inv (float *, float *, float *, float *, int, int_t, int *fmod, int_t *, gridinfo_t *, sLocalLU_t *, SuperLUStat_t **, int_t *, int_t *, int_t, int_t, int_t, int_t, int, int)
void	slsum_fmod_inv_master (float *, float *, float *, float *, int, int, int_t, int *fmod, int_t, int_t *, gridinfo_t *, sLocalLU_t *, SuperLUStat_t **, int_t, int_t, int_t, int_t, int, int)
void	slsum_bmod_inv (float *, float *, float *, float *, int, int_t, int *bmod, int_t *, Ucb_indptr_t **, int_t **, int_t *, gridinfo_t *, sLocalLU_t *, SuperLUStat_t **, int_t *, int_t *, int_t, int_t, int, int)
void	slsum_bmod_inv_master (float *, float *, float *, float *, int, int_t, int *bmod, int_t *, Ucb_indptr_t **, int_t **, int_t *, gridinfo_t *, sLocalLU_t *, SuperLUStat_t **, int_t, int_t, int, int)
void	sComputeLevelsets (int, int_t, gridinfo_t *, Glu_persist_t *, sLocalLU_t *, int_t *)
void	psgsrfs (int_t, SuperMatrix *, float, sLUstruct_t *, sScalePermstruct_t *, gridinfo_t *, float[], int_t, float[], int_t, int, sSOLVEstruct_t *, float *, SuperLUStat_t *, int *)
void	psgsrfs_ABXglobal (int_t, SuperMatrix *, float, sLUstruct_t *, gridinfo_t *, float *, int_t, float *, int_t, int, float *, SuperLUStat_t *, int *)
int	psgsmv_AXglobal_setup (SuperMatrix *, Glu_persist_t *, gridinfo_t *, int_t *, int_t *[], float *[], int_t *[], int_t[])
int	psgsmv_AXglobal (int_t, int_t[], float[], int_t[], float[], float[])
int	psgsmv_AXglobal_abs (int_t, int_t[], float[], int_t[], float[], float[])
void	psgsmv_init (SuperMatrix *, int_t *, gridinfo_t *, psgsmv_comm_t *)
void	psgsmv (int_t, SuperMatrix *, gridinfo_t *, psgsmv_comm_t *, float x[], float ax[])
void	psgsmv_finalize (psgsmv_comm_t *)
float *	floatMalloc_dist (int_t)
float *	floatCalloc_dist (int_t)
void *	duser_malloc_dist (int_t, int_t)
void	duser_free_dist (int_t, int_t)
int_t	sQuerySpace_dist (int_t, sLUstruct_t *, gridinfo_t *, SuperLUStat_t *, superlu_dist_mem_usage_t *)
void	sClone_CompRowLoc_Matrix_dist (SuperMatrix *, SuperMatrix *)
void	sCopy_CompRowLoc_Matrix_dist (SuperMatrix *, SuperMatrix *)
void	sZero_CompRowLoc_Matrix_dist (SuperMatrix *)
	Sets all entries of a matrix to zero, A_{i,j}=0, for i,j=1,..,n. More...
void	sScaleAddId_CompRowLoc_Matrix_dist (SuperMatrix *, float)
	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. More...
void	sScaleAdd_CompRowLoc_Matrix_dist (SuperMatrix *, SuperMatrix *, float)
	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. More...
void	sZeroLblocks (int, int, gridinfo_t *, sLUstruct_t *)
	Sets all entries of matrix L to zero. More...
void	sZeroUblocks (int iam, int n, gridinfo_t *, sLUstruct_t *)
	Sets all entries of matrix U to zero. More...
void	sfill_dist (float *, int_t, float)
	Fills a float precision array with a given value. More...
void	sinf_norm_error_dist (int_t, int_t, float *, int_t, float *, int_t, gridinfo_t *)
	Check the inf-norm of the error vector. More...
void	psinf_norm_error (int, int_t, int_t, float[], int_t, float[], int_t, MPI_Comm)
	Check the inf-norm of the error vector. More...
void	sreadhb_dist (int, FILE *, int_t *, int_t *, int_t *, float **, int_t **, int_t **)
void	sreadtriple_dist (FILE *, int_t *, int_t *, int_t *, float **, int_t **, int_t **)
void	sreadtriple_noheader (FILE *, int_t *, int_t *, int_t *, float **, int_t **, int_t **)
void	sreadrb_dist (int, FILE *, int_t *, int_t *, int_t *, float **, int_t **, int_t **)
void	sreadMM_dist (FILE *, int_t *, int_t *, int_t *, float **, int_t **, int_t **)
int	sread_binary (FILE *, int_t *, int_t *, int_t *, float **, int_t **, int_t **)
float	sdist_psymbtonum (fact_t, int_t, SuperMatrix *, sScalePermstruct_t *, Pslu_freeable_t *, sLUstruct_t *, gridinfo_t *)
void	psGetDiagU (int_t, sLUstruct_t *, gridinfo_t *, float *)
int	s_c2cpp_GetHWPM (SuperMatrix *, gridinfo_t *, sScalePermstruct_t *)
void	sPrintLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, sLocalLU_t *)
	Print the blocks in the factored matrix L. More...
void	sPrintUblocks (int, int_t, gridinfo_t *, Glu_persist_t *, sLocalLU_t *)
	Print the blocks in the factored matrix U. More...
void	sPrint_CompCol_Matrix_dist (SuperMatrix *)
void	sPrint_Dense_Matrix_dist (SuperMatrix *)
int	sPrint_CompRowLoc_Matrix_dist (SuperMatrix *)
int	file_sPrint_CompRowLoc_Matrix_dist (FILE *fp, SuperMatrix *A)
void	Printfloat5 (char *, int_t, float *)
int	file_Printfloat5 (FILE *, char *, int_t, float *)
void	sGenCOOLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, sLocalLU_t *, int_t **, int_t **, float **, int_t *, int_t *)
void	sGenCSCLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, sLocalLU_t *, float **, int_t **, int_t **, int_t *, int_t *)
void	sGenCSRLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, sLocalLU_t *, float **, int_t **, int_t **, int_t *, int_t *)
int	sgemm_ (const char *, const char *, const int *, const int *, const int *, const float *, const float *, const int *, const float *, const int *, const float *, float *, const int *)
int	strsv_ (char *, char *, char *, int *, float *, int *, float *, int *)
int	strsm_ (const char *, const char *, const char *, const char *, const int *, const int *, const float *, const float *, const int *, float *, const int *)
void	sgemv_ (const char *, const int *, const int *, const float *, const float *a, const int *, const float *, const int *, const float *, float *, const int *)
void	sger_ (const int *, const int *, const float *, const float *, const int *, const float *, const int *, float *, const int *)
int	sscal_ (const int *n, const float *alpha, float *dx, const int *incx)
int	saxpy_ (const int *n, const float *alpha, const float *x, const int *incx, float *y, const int *incy)
int	superlu_sgemm (const char *transa, const char *transb, int m, int n, int k, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc)
int	superlu_strsm (const char *sideRL, const char *uplo, const char *transa, const char *diag, const int m, const int n, const float alpha, const float *a, const int lda, float *b, const int ldb)
int	superlu_sger (const int m, const int n, const float alpha, const float *x, const int incx, const float *y, const int incy, float *a, const int lda)
int	superlu_sscal (const int n, const float alpha, float *x, const int incx)
int	superlu_saxpy (const int n, const float alpha, const float *x, const int incx, float *y, const int incy)
int	superlu_sgemv (const char *trans, const int m, const int n, const float alpha, const float *a, const int lda, const float *x, const int incx, const float beta, float *y, const int incy)
int	superlu_strsv (char *uplo, char *trans, char *diag, int n, float *a, int lda, float *x, int incx)
int	screate_matrix3d (SuperMatrix *A, int nrhs, float **rhs, int *ldb, float **x, int *ldx, FILE *fp, gridinfo3d_t *grid3d)
int	screate_matrix_postfix3d (SuperMatrix *A, int nrhs, float **rhs, int *ldb, float **x, int *ldx, FILE *fp, char *postfix, gridinfo3d_t *grid3d)
void	sGatherNRformat_loc3d (fact_t Fact, NRformat_loc *A, float *B, int ldb, int nrhs, gridinfo3d_t *grid3d, NRformat_loc3d **)
int	sScatter_B3d (NRformat_loc3d *A3d, gridinfo3d_t *grid3d)
void	psgssvx3d (superlu_dist_options_t *, SuperMatrix *, sScalePermstruct_t *, float B[], int ldb, int nrhs, gridinfo3d_t *, sLUstruct_t *, sSOLVEstruct_t *, float *berr, SuperLUStat_t *, int *info)
int_t	psgstrf3d (superlu_dist_options_t *, int m, int n, float anorm, trf3Dpartition_t *, SCT_t *, sLUstruct_t *, gridinfo3d_t *, SuperLUStat_t *, int *)
void	sInit_HyP (HyP_t *HyP, sLocalLU_t *Llu, int_t mcb, int_t mrb)
void	Free_HyP (HyP_t *HyP)
int	updateDirtyBit (int_t k0, HyP_t *HyP, gridinfo_t *grid)
void	sblock_gemm_scatter (int_t lb, int_t j, Ublock_info_t *Ublock_info, Remain_info_t *Remain_info, float *L_mat, int ldl, float *U_mat, int ldu, float *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, float **Lnzval_bc_ptr, int_t **Ufstnz_br_ptr, float **Unzval_br_ptr, int_t *xsup, gridinfo_t *, SuperLUStat_t *)
int_t	sblock_gemm_scatterTopLeft (int_t lb, int_t j, float *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, sLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
int_t	sblock_gemm_scatterTopRight (int_t lb, int_t j, float *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, sLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
int_t	sblock_gemm_scatterBottomLeft (int_t lb, int_t j, float *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, sLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
int_t	sblock_gemm_scatterBottomRight (int_t lb, int_t j, float *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, sLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
void	sgather_u (int_t num_u_blks, Ublock_info_t *Ublock_info, int_t *usub, float *uval, float *bigU, int_t ldu, int_t *xsup, int_t klst)
void	sgather_l (int_t num_LBlk, int_t knsupc, Remain_info_t *L_info, float *lval, int_t LD_lval, float *L_buff)
void	sRgather_L (int_t k, int_t *lsub, float *lusup, gEtreeInfo_t *, Glu_persist_t *, gridinfo_t *, HyP_t *, int_t *myIperm, int_t *iperm_c_supno)
void	sRgather_U (int_t k, int_t jj0, int_t *usub, float *uval, float *bigU, gEtreeInfo_t *, Glu_persist_t *, gridinfo_t *, HyP_t *, int_t *myIperm, int_t *iperm_c_supno, int_t *perm_u)
trf3Dpartition_t *	sinitTrf3Dpartition (int_t nsupers, superlu_dist_options_t *options, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
void	sDestroy_trf3Dpartition (trf3Dpartition_t *trf3Dpartition, gridinfo3d_t *grid3d)
void	s3D_printMemUse (trf3Dpartition_t *trf3Dpartition, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
void	sinit3DLUstructForest (int_t *myTreeIdxs, int_t *myZeroTrIdxs, sForest_t **sForests, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	sgatherAllFactoredLUFr (int_t *myZeroTrIdxs, sForest_t *sForests, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	sLpanelUpdate (int_t off0, int_t nsupc, float *ublk_ptr, int_t ld_ujrow, float *lusup, int_t nsupr, SCT_t *)
void	Local_Sgstrf2 (superlu_dist_options_t *options, int_t k, double thresh, float *BlockUFactor, Glu_persist_t *, gridinfo_t *, sLocalLU_t *, SuperLUStat_t *, int *info, SCT_t *)
int_t	sTrs2_GatherU (int_t iukp, int_t rukp, int_t klst, int_t nsupc, int_t ldu, int_t *usub, float *uval, float *tempv)
int_t	sTrs2_ScatterU (int_t iukp, int_t rukp, int_t klst, int_t nsupc, int_t ldu, int_t *usub, float *uval, float *tempv)
int_t	sTrs2_GatherTrsmScatter (int_t klst, int_t iukp, int_t rukp, int_t *usub, float *uval, float *tempv, int_t knsupc, int nsupr, float *lusup, Glu_persist_t *Glu_persist)
void	psgstrs2 (int_t m, int_t k0, int_t k, Glu_persist_t *Glu_persist, gridinfo_t *grid, sLocalLU_t *Llu, SuperLUStat_t *stat)
void	psgstrf2 (superlu_dist_options_t *, int_t nsupers, int_t k0, int_t k, double thresh, Glu_persist_t *, gridinfo_t *, sLocalLU_t *, MPI_Request *, int, SuperLUStat_t *, int *)
int_t	sAllocLlu_3d (int_t nsupers, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	sp3dScatter (int_t n, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	sscatter3dLPanels (int_t nsupers, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	sscatter3dUPanels (int_t nsupers, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	scollect3dLpanels (int_t layer, int_t nsupers, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	scollect3dUpanels (int_t layer, int_t nsupers, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	sp3dCollect (int_t layer, int_t n, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	szeroSetLU (int_t nnodes, int_t *nodeList, sLUstruct_t *, gridinfo3d_t *)
int	sAllocGlu_3d (int_t n, int_t nsupers, sLUstruct_t *)
int	sDeAllocLlu_3d (int_t n, sLUstruct_t *, gridinfo3d_t *)
int	sDeAllocGlu_3d (sLUstruct_t *)
int_t	sreduceAncestors3d (int_t sender, int_t receiver, int_t nnodes, int_t *nodeList, float *Lval_buf, float *Uval_buf, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int	sreduceAllAncestors3d (int_t ilvl, int_t *myNodeCount, int_t **treePerm, sLUValSubBuf_t *LUvsb, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	sgatherFactoredLU (int_t sender, int_t receiver, int_t nnodes, int_t *nodeList, sLUValSubBuf_t *LUvsb, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	sgatherAllFactoredLU (trf3Dpartition_t *trf3Dpartition, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	sinit3DLUstruct (int_t *myTreeIdxs, int_t *myZeroTrIdxs, int_t *nodeCount, int_t **nodeList, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
int_t	szSendLPanel (int_t k, int_t receiver, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	szRecvLPanel (int_t k, int_t sender, float alpha, float beta, float *Lval_buf, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	szSendUPanel (int_t k, int_t receiver, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	szRecvUPanel (int_t k, int_t sender, float alpha, float beta, float *Uval_buf, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
int_t	sIBcast_LPanel (int_t k, int_t k0, int_t *lsub, float *lusup, gridinfo_t *, int *msgcnt, MPI_Request *, int **ToSendR, int_t *xsup, int)
int_t	sBcast_LPanel (int_t k, int_t k0, int_t *lsub, float *lusup, gridinfo_t *, int *msgcnt, int **ToSendR, int_t *xsup, SCT_t *, int)
int_t	sIBcast_UPanel (int_t k, int_t k0, int_t *usub, float *uval, gridinfo_t *, int *msgcnt, MPI_Request *, int *ToSendD, int)
int_t	sBcast_UPanel (int_t k, int_t k0, int_t *usub, float *uval, gridinfo_t *, int *msgcnt, int *ToSendD, SCT_t *, int)
int_t	sIrecv_LPanel (int_t k, int_t k0, int_t *Lsub_buf, float *Lval_buf, gridinfo_t *, MPI_Request *, sLocalLU_t *, int)
int_t	sIrecv_UPanel (int_t k, int_t k0, int_t *Usub_buf, float *, sLocalLU_t *, gridinfo_t *, MPI_Request *, int)
int_t	sWait_URecv (MPI_Request *, int *msgcnt, SCT_t *)
int_t	sWait_LRecv (MPI_Request *, int *msgcnt, int *msgcntsU, gridinfo_t *, SCT_t *)
int_t	sISend_UDiagBlock (int_t k0, float *ublk_ptr, int_t size, MPI_Request *, gridinfo_t *, int)
int_t	sRecv_UDiagBlock (int_t k0, float *ublk_ptr, int_t size, int_t src, gridinfo_t *, SCT_t *, int)
int_t	sPackLBlock (int_t k, float *Dest, Glu_persist_t *, gridinfo_t *, sLocalLU_t *)
int_t	sISend_LDiagBlock (int_t k0, float *lblk_ptr, int_t size, MPI_Request *, gridinfo_t *, int)
int_t	sIRecv_UDiagBlock (int_t k0, float *ublk_ptr, int_t size, int_t src, MPI_Request *, gridinfo_t *, SCT_t *, int)
int_t	sIRecv_LDiagBlock (int_t k0, float *L_blk_ptr, int_t size, int_t src, MPI_Request *, gridinfo_t *, SCT_t *, int)
int_t	sUDiagBlockRecvWait (int_t k, int_t *IrecvPlcd_D, int_t *factored_L, MPI_Request *, gridinfo_t *, sLUstruct_t *, SCT_t *)
int_t	LDiagBlockRecvWait (int_t k, int_t *factored_U, MPI_Request *, gridinfo_t *)
int_t	sDiagFactIBCast (int_t k, int_t k0, float *BlockUFactor, float *BlockLFactor, int_t *IrecvPlcd_D, MPI_Request *, MPI_Request *, MPI_Request *, MPI_Request *, gridinfo_t *, superlu_dist_options_t *, double thresh, sLUstruct_t *LUstruct, SuperLUStat_t *, int *info, SCT_t *, int tag_ub)
int_t	sUPanelTrSolve (int_t k, float *BlockLFactor, float *bigV, int_t ldt, Ublock_info_t *, gridinfo_t *, sLUstruct_t *, SuperLUStat_t *, SCT_t *)
int_t	sLPanelUpdate (int_t k, int_t *IrecvPlcd_D, int_t *factored_L, MPI_Request *, float *BlockUFactor, gridinfo_t *, sLUstruct_t *, SCT_t *)
int_t	sUPanelUpdate (int_t k, int_t *factored_U, MPI_Request *, float *BlockLFactor, float *bigV, int_t ldt, Ublock_info_t *, gridinfo_t *, sLUstruct_t *, SuperLUStat_t *, SCT_t *)
int_t	sIBcastRecvLPanel (int_t k, int_t k0, int *msgcnt, MPI_Request *, MPI_Request *, int_t *Lsub_buf, float *Lval_buf, int_t *factored, gridinfo_t *, sLUstruct_t *, SCT_t *, int tag_ub)
int_t	sIBcastRecvUPanel (int_t k, int_t k0, int *msgcnt, MPI_Request *, MPI_Request *, int_t *Usub_buf, float *Uval_buf, gridinfo_t *, sLUstruct_t *, SCT_t *, int tag_ub)
int_t	sWaitL (int_t k, int *msgcnt, int *msgcntU, MPI_Request *, MPI_Request *, gridinfo_t *, sLUstruct_t *, SCT_t *)
int_t	sWaitU (int_t k, int *msgcnt, MPI_Request *, MPI_Request *, gridinfo_t *, sLUstruct_t *, SCT_t *)
int_t	sLPanelTrSolve (int_t k, int_t *factored_L, float *BlockUFactor, gridinfo_t *, sLUstruct_t *)
int	getNsupers (int, Glu_persist_t *)
int_t	initPackLUInfo (int_t nsupers, packLUInfo_t *packLUInfo)
int	freePackLUInfo (packLUInfo_t *packLUInfo)
int_t	sSchurComplementSetup (int_t k, int *msgcnt, Ublock_info_t *, Remain_info_t *, uPanelInfo_t *, lPanelInfo_t *, int_t *, int_t *, int_t *, float *bigU, int_t *Lsub_buf, float *Lval_buf, int_t *Usub_buf, float *Uval_buf, gridinfo_t *, sLUstruct_t *)
int_t	sSchurComplementSetupGPU (int_t k, msgs_t *msgs, packLUInfo_t *, int_t *, int_t *, int_t *, gEtreeInfo_t *, factNodelists_t *, sscuBufs_t *, sLUValSubBuf_t *LUvsb, gridinfo_t *, sLUstruct_t *, HyP_t *)
float *	sgetBigV (int_t, int_t)
float *	sgetBigU (int_t, gridinfo_t *, sLUstruct_t *)
int_t	sLluBufInit (sLUValSubBuf_t *, sLUstruct_t *)
int_t	sinitScuBufs (int_t ldt, int_t num_threads, int_t nsupers, sscuBufs_t *, sLUstruct_t *, gridinfo_t *)
int	sfreeScuBufs (sscuBufs_t *scuBufs)
int_t	treeFactor (int_t nnnodes, int_t *perm_c_supno, commRequests_t *comReqs, sscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t *msgs, sLUValSubBuf_t *LUvsb, sdiagFactBufs_t *dFBuf, factStat_t *factStat, factNodelists_t *fNlists, superlu_dist_options_t *options, int_t *gIperm_c_supno, int_t ldt, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int *info)
int_t	ssparseTreeFactor (int_t nnodes, int_t *perm_c_supno, treeTopoInfo_t *treeTopoInfo, commRequests_t *comReqs, sscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t *msgs, sLUValSubBuf_t *LUvsb, sdiagFactBufs_t *dFBuf, factStat_t *factStat, factNodelists_t *fNlists, superlu_dist_options_t *options, int_t *gIperm_c_supno, int_t ldt, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int *info)
int_t	sdenseTreeFactor (int_t nnnodes, int_t *perm_c_supno, commRequests_t *comReqs, sscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t *msgs, sLUValSubBuf_t *LUvsb, sdiagFactBufs_t *dFBuf, factStat_t *factStat, factNodelists_t *fNlists, superlu_dist_options_t *options, int_t *gIperm_c_supno, int_t ldt, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int tag_ub, int *info)
int_t	ssparseTreeFactor_ASYNC (sForest_t *sforest, commRequests_t **comReqss, sscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t **msgss, sLUValSubBuf_t **LUvsbs, sdiagFactBufs_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, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int tag_ub, int *info)
sLUValSubBuf_t **	sLluBufInitArr (int_t numLA, sLUstruct_t *LUstruct)
int	sLluBufFreeArr (int_t numLA, sLUValSubBuf_t **LUvsbs)
sdiagFactBufs_t **	sinitDiagFactBufsArr (int_t mxLeafNode, int_t ldt, gridinfo_t *grid)
int	sfreeDiagFactBufsArr (int_t mxLeafNode, sdiagFactBufs_t **dFBufs)
int_t	sinitDiagFactBufs (int_t ldt, sdiagFactBufs_t *dFBuf)
int_t	checkRecvUDiag (int_t k, commRequests_t *comReqs, gridinfo_t *grid, SCT_t *SCT)
int_t	checkRecvLDiag (int_t k, commRequests_t *comReqs, gridinfo_t *, SCT_t *)
int_t	ancestorFactor (int_t ilvl, sForest_t *sforest, commRequests_t **comReqss, sscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t **msgss, sLUValSubBuf_t **LUvsbs, sdiagFactBufs_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, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int tag_ub, int *info)

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 7.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

Function Documentation

ancestorFactor()

int_t ancestorFactor	(	int_t	ilvl,
		sForest_t *	sforest,
		commRequests_t **	comReqss,
		sscuBufs_t *	scuBufs,
		packLUInfo_t *	packLUInfo,
		msgs_t **	msgss,
		sLUValSubBuf_t **	LUvsbs,
		sdiagFactBufs_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,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SuperLUStat_t *	stat,
		double	thresh,
		SCT_t *	SCT,
		int	tag_ub,
		int *	info
	)

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
	)

duser_free_dist()

void duser_free_dist	(	int_t	bytes,
		int_t	which_end
	)

duser_malloc_dist()

void * duser_malloc_dist	(	int_t	bytes,
		int_t	which_end
	)

file_Printfloat5()

int file_Printfloat5	(	FILE *	fp,
		char *	name,
		int_t	len,
		float *	x
	)

file_sPrint_CompRowLoc_Matrix_dist()

int file_sPrint_CompRowLoc_Matrix_dist	(	FILE *	fp,
		SuperMatrix *	A
	)

floatCalloc_dist()

float * floatCalloc_dist

(

int_t

n

)

floatMalloc_dist()

float * floatMalloc_dist

(

int_t

n

)

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
	)

LDiagBlockRecvWait()

int_t LDiagBlockRecvWait	(	int_t	k,
		int_t *	factored_U,
		MPI_Request *	L_diag_blk_recv_req,
		gridinfo_t *	grid
	)

Local_Sgstrf2()

void Local_Sgstrf2	(	superlu_dist_options_t *	options,
		int_t	k,
		double	thresh,
		float *	BlockUFactor,
		Glu_persist_t *	,
		gridinfo_t *	,
		sLocalLU_t *	,
		SuperLUStat_t *	,
		int *	info,
		SCT_t *
	)

Here is the caller graph for this function:

Printfloat5()

void Printfloat5	(	char *	name,
		int_t	len,
		float *	x
	)

Here is the caller graph for this function:

psCompRow_loc_to_CompCol_global()

int psCompRow_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.

psCompute_Diag_Inv()

void psCompute_Diag_Inv	(	int_t	n,
		sLUstruct_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.

psdistribute()

float psdistribute	(	fact_t	fact,
		int_t	n,
		SuperMatrix *	A,
		sScalePermstruct_t *	ScalePermstruct,
		Glu_freeable_t *	Glu_freeable,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid
	)

Here is the call graph for this function:

Here is the caller graph for this function:

psGetDiagU()

void psGetDiagU	(	int_t	n,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid,
		float *	diagU
	)

Purpose
=======

GetDiagU extracts the main diagonal of matrix U of the LU factorization.

Arguments
=========

n        (input) int
         Dimension of the matrix.

LUstruct (input) sLUstruct_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 psgstrs_Bglobal.c.

psgsequ()

void psgsequ	(	SuperMatrix *	A,
		float *	r,
		float *	c,
		float *	rowcnd,
		float *	colcnd,
		float *	amax,
		int_t *	info,
		gridinfo_t *	grid
	)

    Purpose
    =======

    PSGSEQU 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_S; Mtype = SLU_GE.

    R       (output) float*, size A->nrow
            If INFO = 0 or INFO > M, R contains the row scale factors
            for A.

    C       (output) float*, size A->ncol
            If INFO = 0,  C contains the column scale factors for A.

    ROWCND  (output) float*
            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) float*
            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) float*
            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.
    =====================================================================

psgsmv()

void psgsmv	(	int_t	abs,
		SuperMatrix *	A_internal,
		gridinfo_t *	grid,
		psgsmv_comm_t *	gsmv_comm,
		float	x[],
		float	ax[]
	)

psgsmv_AXglobal()

int psgsmv_AXglobal	(	int_t	m,
		int_t	update[],
		float	val[],
		int_t	bindx[],
		float	X[],
		float	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

psgsmv_AXglobal_abs()

int psgsmv_AXglobal_abs	(	int_t	m,
		int_t	update[],
		float	val[],
		int_t	bindx[],
		float	X[],
		float	ax[]
	)

psgsmv_AXglobal_setup()

int psgsmv_AXglobal_setup	(	SuperMatrix *	,
		Glu_persist_t *	,
		gridinfo_t *	,
		int_t *	,
		int_t *	[],
		float *	[],
		int_t *	[],
		int_t	[]
	)

psgsmv_finalize()

void psgsmv_finalize

(

psgsmv_comm_t *

gsmv_comm

)

psgsmv_init()

void psgsmv_init	(	SuperMatrix *	A,
		int_t *	row_to_proc,
		gridinfo_t *	grid,
		psgsmv_comm_t *	gsmv_comm
	)

psgsrfs()

void psgsrfs	(	int_t	,
		SuperMatrix *	,
		float	,
		sLUstruct_t *	,
		sScalePermstruct_t *	,
		gridinfo_t *	,
		float	[],
		int_t	,
		float	[],
		int_t	,
		int	,
		sSOLVEstruct_t *	,
		float *	,
		SuperLUStat_t *	,
		int *
	)

psgsrfs_ABXglobal()

void psgsrfs_ABXglobal	(	int_t	n,
		SuperMatrix *	A,
		float	anorm,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid,
		float *	B,
		int_t	ldb,
		float *	X,
		int_t	ldx,
		int	nrhs,
		float *	berr,
		SuperLUStat_t *	stat,
		int *	info
	)

Purpose
=======

psgsrfs_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_S; 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) sLUstruct_t*
       The distributed data structures storing L and U factors.
       The L and U factors are obtained from psgstrf for
       the possibly scaled and permuted matrix A.
       See superlu_ddefs.h for the definition of 'sLUstruct_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) float* (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) float* (global)
       On entry, the solution matrix X, as computed by PSGSTRS.
       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:

psgssvx()

void psgssvx	(	superlu_dist_options_t *	,
		SuperMatrix *	,
		sScalePermstruct_t *	,
		float *	,
		int	,
		int	,
		gridinfo_t *	,
		sLUstruct_t *	,
		sSOLVEstruct_t *	,
		float *	,
		SuperLUStat_t *	,
		int *
	)

psgssvx3d()

void psgssvx3d	(	superlu_dist_options_t *	options,
		SuperMatrix *	A,
		sScalePermstruct_t *	ScalePermstruct,
		float	B[],
		int	ldb,
		int	nrhs,
		gridinfo3d_t *	grid3d,
		sLUstruct_t *	LUstruct,
		sSOLVEstruct_t *	SOLVEstruct,
		float *	berr,
		SuperLUStat_t *	stat,
		int *	info
	)

psgssvx_ABglobal()

void psgssvx_ABglobal	(	superlu_dist_options_t *	,
		SuperMatrix *	,
		sScalePermstruct_t *	,
		float *	,
		int	,
		int	,
		gridinfo_t *	,
		sLUstruct_t *	,
		float *	,
		SuperLUStat_t *	,
		int *
	)

psgstrf()

int_t psgstrf	(	superlu_dist_options_t *	options,
		int	m,
		int	n,
		float	anorm,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid,
		SuperLUStat_t *	stat,
		int *	info
	)

Purpose
=======

PSGSTRF 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)
          Specifies whether to replace the tiny diagonals 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) float
       The norm of the original matrix A, or the scaled A if
       equilibration was done.

LUstruct (input/output) sLUstruct_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) sLocalLU_t*
          The distributed data structures to store L and U factors.
          See superlu_sdefs.h for the definition of 'sLocalLU_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.

Purpose
=======

PSGSTRF 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) float
       The norm of the original matrix A, or the scaled A if
       equilibration was done.

LUstruct (input/output) sLUstruct_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) sLocalLU_t*
          The distributed data structures to store L and U factors.
          See superlu_sdefs.h for the definition of 'sLocalLU_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.

psgstrf2()

void psgstrf2	(	superlu_dist_options_t *	,
		int_t	nsupers,
		int_t	k0,
		int_t	k,
		double	thresh,
		Glu_persist_t *	,
		gridinfo_t *	,
		sLocalLU_t *	,
		MPI_Request *	,
		int	,
		SuperLUStat_t *	,
		int *
	)

psgstrf2_trsm()

void psgstrf2_trsm	(	superlu_dist_options_t *	options,
		int_t	k0,
		int_t	k,
		double	thresh,
		Glu_persist_t *	Glu_persist,
		gridinfo_t *	grid,
		sLocalLU_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) sLocalLU_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

ALWAYS SEND TO ALL OTHERS - TO FIX

psgstrf3d()

int_t psgstrf3d	(	superlu_dist_options_t *	options,
		int	m,
		int	n,
		float	anorm,
		trf3Dpartition_t *	trf3Dpartition,
		SCT_t *	SCT,
		sLUstruct_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:

psgstrs()

void psgstrs	(	int_t	n,
		sLUstruct_t *	LUstruct,
		sScalePermstruct_t *	ScalePermstruct,
		gridinfo_t *	grid,
		float *	B,
		int_t	m_loc,
		int_t	fst_row,
		int_t	ldb,
		int	nrhs,
		sSOLVEstruct_t *	SOLVEstruct,
		SuperLUStat_t *	stat,
		int *	info
	)

Purpose
=======

PSGSTRS solves a system of distributed linear equations
A*X = B with a general N-by-N matrix A using the LU factorization
computed by PSGSTRF.
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) sLUstruct_t*
       The distributed data structures storing L and U factors.
       The L and U factors are obtained from PSGSTRF for
       the possibly scaled and permuted matrix A.
       See superlu_sdefs.h for the definition of 'sLUstruct_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) float*
       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) sSOLVEstruct_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:

psgstrs2()

void psgstrs2	(	int_t	m,
		int_t	k0,
		int_t	k,
		Glu_persist_t *	Glu_persist,
		gridinfo_t *	grid,
		sLocalLU_t *	Llu,
		SuperLUStat_t *	stat
	)

psgstrs2_omp()

void psgstrs2_omp	(	int_t	k0,
		int_t	k,
		Glu_persist_t *	Glu_persist,
		gridinfo_t *	grid,
		sLocalLU_t *	Llu,
		Ublock_info_t *	Ublock_info,
		SuperLUStat_t *	stat
	)

4/19/2019

4/19/2019

psgstrs_Bglobal()

void psgstrs_Bglobal	(	int_t	n,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid,
		float *	B,
		int_t	ldb,
		int	nrhs,
		SuperLUStat_t *	stat,
		int *	info
	)

Purpose
=======

psgstrs_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 psgstrf.

Arguments
=========

n      (input) int (global)
       The order of the system of linear equations.

LUstruct (input) sLUstruct_t*
       The distributed data structures storing L and U factors.
       The L and U factors are obtained from psgstrf for
       the possibly scaled and permuted matrix A.
       See superlu_ddefs.h for the definition of 'sLUstruct_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) float*
       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:

psgstrs_init()

int_t psgstrs_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,
		sSOLVEstruct_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.

psinf_norm_error()

void psinf_norm_error	(	int	iam,
		int_t	n,
		int_t	nrhs,
		float	x[],
		int_t	ldx,
		float	xtrue[],
		int_t	ldxtrue,
		MPI_Comm	slucomm
	)

Check the inf-norm of the error vector.

pslangs()

float pslangs	(	char *	norm,
		SuperMatrix *	A,
		gridinfo_t *	grid
	)

    Purpose
    =======

    PSLANGS 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
    ===========

    PSLANGE returns the value

       PSLANGE = ( 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.
   =====================================================================

pslaqgs()

void pslaqgs	(	SuperMatrix *	A,
		float *	r,
		float *	c,
		float	rowcnd,
		float	colcnd,
		float	amax,
		char *	equed
	)

    Purpose
    =======

    PSLAQGS 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_S; Mtype = SLU_GE.

    R       (input) float*, dimension (A->nrow)
            The row scale factors for A.

    C       (input) float*, dimension (A->ncol)
            The column scale factors for A.

    ROWCND  (input) float
            Ratio of the smallest R(i) to the largest R(i).

    COLCND  (input) float
            Ratio of the smallest C(i) to the largest C(i).

    AMAX    (input) float
            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.

    =====================================================================

psPermute_Dense_Matrix()

int psPermute_Dense_Matrix	(	int_t	fst_row,
		int_t	m_loc,
		int_t	row_to_proc[],
		int_t	perm[],
		float	X[],
		int	ldx,
		float	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.

psReDistribute_B_to_X()

int_t psReDistribute_B_to_X	(	float *	B,
		int_t	m_loc,
		int	nrhs,
		int_t	ldb,
		int_t	fst_row,
		int_t *	ilsum,
		float *	x,
		sScalePermstruct_t *	ScalePermstruct,
		Glu_persist_t *	Glu_persist,
		gridinfo_t *	grid,
		sSOLVEstruct_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 psgstrs_init(),
  in which the structures of the send and receive buffers are set up.

Arguments
=========

B      (input) float*
       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) float*
       The solution vector. It is valid only on the diagonal processes.

ScalePermstruct (input) sScalePermstruct_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) sSOLVEstruct_t*
       Contains the information for the communication during the
       solution phase.

Return value
============

pxgstrs_finalize()

void pxgstrs_finalize

(

pxgstrs_comm_t *

gstrs_comm

)

s3D_printMemUse()

void s3D_printMemUse	(	trf3Dpartition_t *	trf3Dpartition,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

Here is the call graph for this function:

Here is the caller graph for this function:

s_c2cpp_GetHWPM()

int s_c2cpp_GetHWPM	(	SuperMatrix *	A,
		gridinfo_t *	grid,
		sScalePermstruct_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_S; Mtype = SLU_GE.

grid   (input) gridinfo_t*
       SuperLU's 2D process mesh.

ScalePermstruct (output) sScalePermstruct_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:

sallocateA_dist()

void sallocateA_dist	(	int_t	n,
		int_t	nnz,
		float **	a,
		int_t **	asub,
		int_t **	xa
	)

sAllocGlu_3d()

int sAllocGlu_3d	(	int_t	n,
		int_t	nsupers,
		sLUstruct_t *	LUstruct
	)

Here is the call graph for this function:

sAllocLlu_3d()

int_t sAllocLlu_3d	(	int_t	nsupers,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

saxpy_()

int saxpy_	(	const int *	n,
		const float *	alpha,
		const float *	x,
		const int *	incx,
		float *	y,
		const int *	incy
	)

sBcast_LPanel()

int_t sBcast_LPanel	(	int_t	k,
		int_t	k0,
		int_t *	lsub,
		float *	lusup,
		gridinfo_t *	,
		int *	msgcnt,
		int **	ToSendR,
		int_t *	xsup,
		SCT_t *	,
		int
	)

sBcast_UPanel()

int_t sBcast_UPanel	(	int_t	k,
		int_t	k0,
		int_t *	usub,
		float *	uval,
		gridinfo_t *	,
		int *	msgcnt,
		int *	ToSendD,
		SCT_t *	,
		int
	)

sblock_gemm_scatter()

void sblock_gemm_scatter	(	int_t	lb,
		int_t	j,
		Ublock_info_t *	Ublock_info,
		Remain_info_t *	Remain_info,
		float *	L_mat,
		int	ldl,
		float *	U_mat,
		int	ldu,
		float *	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,
		float **	Lnzval_bc_ptr,
		int_t **	Ufstnz_br_ptr,
		float **	Unzval_br_ptr,
		int_t *	xsup,
		gridinfo_t *	,
		SuperLUStat_t *
	)

sblock_gemm_scatterBottomLeft()

int_t sblock_gemm_scatterBottomLeft	(	int_t	lb,
		int_t	j,
		float *	bigV,
		int_t	knsupc,
		int_t	klst,
		int_t *	lsub,
		int_t *	usub,
		int_t	ldt,
		int *	indirect,
		int *	indirect2,
		HyP_t *	HyP,
		sLUstruct_t *	,
		gridinfo_t *	,
		SCT_t *	SCT,
		SuperLUStat_t *
	)

sblock_gemm_scatterBottomRight()

int_t sblock_gemm_scatterBottomRight	(	int_t	lb,
		int_t	j,
		float *	bigV,
		int_t	knsupc,
		int_t	klst,
		int_t *	lsub,
		int_t *	usub,
		int_t	ldt,
		int *	indirect,
		int *	indirect2,
		HyP_t *	HyP,
		sLUstruct_t *	,
		gridinfo_t *	,
		SCT_t *	SCT,
		SuperLUStat_t *
	)

sblock_gemm_scatterTopLeft()

int_t sblock_gemm_scatterTopLeft	(	int_t	lb,
		int_t	j,
		float *	bigV,
		int_t	knsupc,
		int_t	klst,
		int_t *	lsub,
		int_t *	usub,
		int_t	ldt,
		int *	indirect,
		int *	indirect2,
		HyP_t *	HyP,
		sLUstruct_t *	,
		gridinfo_t *	,
		SCT_t *	SCT,
		SuperLUStat_t *
	)

sblock_gemm_scatterTopRight()

int_t sblock_gemm_scatterTopRight	(	int_t	lb,
		int_t	j,
		float *	bigV,
		int_t	knsupc,
		int_t	klst,
		int_t *	lsub,
		int_t *	usub,
		int_t	ldt,
		int *	indirect,
		int *	indirect2,
		HyP_t *	HyP,
		sLUstruct_t *	,
		gridinfo_t *	,
		SCT_t *	SCT,
		SuperLUStat_t *
	)

sClone_CompRowLoc_Matrix_dist()

void sClone_CompRowLoc_Matrix_dist	(	SuperMatrix *	,
		SuperMatrix *
	)

Here is the caller graph for this function:

scollect3dLpanels()

int_t scollect3dLpanels	(	int_t	layer,
		int_t	nsupers,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

scollect3dUpanels()

int_t scollect3dUpanels	(	int_t	layer,
		int_t	nsupers,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

sCompRow_to_CompCol_dist()

void sCompRow_to_CompCol_dist	(	int_t	,
		int_t	,
		int_t	,
		float *	,
		int_t *	,
		int_t *	,
		float **	,
		int_t **	,
		int_t **
	)

Here is the caller graph for this function:

sComputeLevelsets()

void sComputeLevelsets	(	int	,
		int_t	,
		gridinfo_t *	,
		Glu_persist_t *	,
		sLocalLU_t *	,
		int_t *
	)

sCopy_CompCol_Matrix_dist()

void sCopy_CompCol_Matrix_dist	(	SuperMatrix *	,
		SuperMatrix *
	)

sCopy_CompRowLoc_Matrix_dist()

void sCopy_CompRowLoc_Matrix_dist	(	SuperMatrix *	A,
		SuperMatrix *	B
	)

sCopy_Dense_Matrix_dist()

void sCopy_Dense_Matrix_dist	(	int_t	,
		int_t	,
		float *	,
		int_t	,
		float *	,
		int_t
	)

Here is the caller graph for this function:

sCreate_CompCol_Matrix_dist()

void sCreate_CompCol_Matrix_dist	(	SuperMatrix *	,
		int_t	,
		int_t	,
		int_t	,
		float *	,
		int_t *	,
		int_t *	,
		Stype_t	,
		Dtype_t	,
		Mtype_t
	)

Here is the caller graph for this function:

sCreate_CompRowLoc_Matrix_dist()

void sCreate_CompRowLoc_Matrix_dist	(	SuperMatrix *	,
		int_t	,
		int_t	,
		int_t	,
		int_t	,
		int_t	,
		float *	,
		int_t *	,
		int_t *	,
		Stype_t	,
		Dtype_t	,
		Mtype_t
	)

Here is the caller graph for this function:

sCreate_Dense_Matrix_dist()

void sCreate_Dense_Matrix_dist	(	SuperMatrix *	,
		int_t	,
		int_t	,
		float *	,
		int_t	,
		Stype_t	,
		Dtype_t	,
		Mtype_t
	)

screate_matrix()

int screate_matrix	(	SuperMatrix *	A,
		int	nrhs,
		float **	rhs,
		int *	ldb,
		float **	x,
		int *	ldx,
		FILE *	fp,
		gridinfo_t *	grid
	)

Here is the call graph for this function:

Here is the caller graph for this function:

screate_matrix3d()

int screate_matrix3d	(	SuperMatrix *	A,
		int	nrhs,
		float **	rhs,
		int *	ldb,
		float **	x,
		int *	ldx,
		FILE *	fp,
		gridinfo3d_t *	grid3d
	)

screate_matrix_dat()

int screate_matrix_dat	(	SuperMatrix *	,
		int	,
		float **	,
		int *	,
		float **	,
		int *	,
		FILE *	,
		gridinfo_t *
	)

screate_matrix_postfix()

int screate_matrix_postfix	(	SuperMatrix *	A,
		int	nrhs,
		float **	rhs,
		int *	ldb,
		float **	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:

screate_matrix_postfix3d()

int screate_matrix_postfix3d	(	SuperMatrix *	A,
		int	nrhs,
		float **	rhs,
		int *	ldb,
		float **	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:

screate_matrix_rb()

int screate_matrix_rb	(	SuperMatrix *	,
		int	,
		float **	,
		int *	,
		float **	,
		int *	,
		FILE *	,
		gridinfo_t *
	)

sCreate_SuperNode_Matrix_dist()

void sCreate_SuperNode_Matrix_dist	(	SuperMatrix *	,
		int_t	,
		int_t	,
		int_t	,
		float *	,
		int_t *	,
		int_t *	,
		int_t *	,
		int_t *	,
		int_t *	,
		Stype_t	,
		Dtype_t	,
		Mtype_t
	)

scuStatUpdate()

int_t scuStatUpdate	(	int_t	knsupc,
		HyP_t *	HyP,
		SCT_t *	SCT,
		SuperLUStat_t *	stat
	)

sDeAllocGlu_3d()

int sDeAllocGlu_3d

(

sLUstruct_t *

LUstruct

)

Here is the caller graph for this function:

sDeAllocLlu_3d()

int sDeAllocLlu_3d	(	int_t	n,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

Here is the caller graph for this function:

sdenseTreeFactor()

int_t sdenseTreeFactor	(	int_t	nnnodes,
		int_t *	perm_c_supno,
		commRequests_t *	comReqs,
		sscuBufs_t *	scuBufs,
		packLUInfo_t *	packLUInfo,
		msgs_t *	msgs,
		sLUValSubBuf_t *	LUvsb,
		sdiagFactBufs_t *	dFBuf,
		factStat_t *	factStat,
		factNodelists_t *	fNlists,
		superlu_dist_options_t *	options,
		int_t *	gIperm_c_supno,
		int_t	ldt,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SuperLUStat_t *	stat,
		double	thresh,
		SCT_t *	SCT,
		int	tag_ub,
		int *	info
	)

sDestroy_A3d_gathered_on_2d()

void sDestroy_A3d_gathered_on_2d	(	sSOLVEstruct_t *	SOLVEstruct,
		gridinfo3d_t *	grid3d
	)

sDestroy_LU()

void sDestroy_LU	(	int_t	n,
		gridinfo_t *	grid,
		sLUstruct_t *	LUstruct
	)

Destroy distributed L & U matrices.

sDestroy_Tree()

void sDestroy_Tree	(	int_t	n,
		gridinfo_t *	grid,
		sLUstruct_t *	LUstruct
	)

Destroy broadcast and reduction trees used in triangular solve.

sDestroy_trf3Dpartition()

void sDestroy_trf3Dpartition	(	trf3Dpartition_t *	trf3Dpartition,
		gridinfo3d_t *	grid3d
	)

Here is the caller graph for this function:

sDiagFactIBCast()

int_t sDiagFactIBCast	(	int_t	k,
		int_t	k0,
		float *	BlockUFactor,
		float *	BlockLFactor,
		int_t *	IrecvPlcd_D,
		MPI_Request *	,
		MPI_Request *	,
		MPI_Request *	,
		MPI_Request *	,
		gridinfo_t *	,
		superlu_dist_options_t *	,
		double	thresh,
		sLUstruct_t *	LUstruct,
		SuperLUStat_t *	,
		int *	info,
		SCT_t *	,
		int	tag_ub
	)

Here is the caller graph for this function:

sdist_psymbtonum()

float sdist_psymbtonum	(	fact_t	fact,
		int_t	n,
		SuperMatrix *	A,
		sScalePermstruct_t *	ScalePermstruct,
		Pslu_freeable_t *	Pslu_freeable,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid
	)

Purpose
=======
  Distribute the input matrix onto the 2D process mesh.

Arguments
=========

fact (input) fact_t
       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) sScalePermstruct_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) sLUstruct_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:

sdistribute()

float sdistribute	(	fact_t	fact,
		int_t	n,
		SuperMatrix *	A,
		Glu_freeable_t *	Glu_freeable,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid
	)

Purpose
=======
  Distribute the matrix onto the 2D process mesh.

Arguments
=========

fact (input) fact_t
       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_S; Mtype = SLU_GE.

LUstruct (input) sLUstruct_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:

sfill_dist()

void sfill_dist	(	float *	a,
		int_t	alen,
		float	dval
	)

Fills a float precision array with a given value.

sFillRHS_dist()

void sFillRHS_dist	(	char *	trans,
		int_t	nrhs,
		float *	x,
		int_t	ldx,
		SuperMatrix *	A,
		float *	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:

sfreeDiagFactBufsArr()

int sfreeDiagFactBufsArr	(	int_t	mxLeafNode,
		sdiagFactBufs_t **	dFBufs
	)

Here is the caller graph for this function:

sfreeScuBufs()

int sfreeScuBufs

(

sscuBufs_t *

scuBufs

)

Here is the caller graph for this function:

sgather_l()

void sgather_l	(	int_t	num_LBlk,
		int_t	knsupc,
		Remain_info_t *	L_info,
		float *	lval,
		int_t	LD_lval,
		float *	L_buff
	)

sgather_u()

void sgather_u	(	int_t	num_u_blks,
		Ublock_info_t *	Ublock_info,
		int_t *	usub,
		float *	uval,
		float *	bigU,
		int_t	ldu,
		int_t *	xsup,
		int_t	klst
	)

sgatherAllFactoredLU()

int_t sgatherAllFactoredLU	(	trf3Dpartition_t *	trf3Dpartition,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

Here is the caller graph for this function:

sgatherAllFactoredLUFr()

int_t sgatherAllFactoredLUFr	(	int_t *	myZeroTrIdxs,
		sForest_t *	sForests,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

sgatherFactoredLU()

int_t sgatherFactoredLU	(	int_t	sender,
		int_t	receiver,
		int_t	nnodes,
		int_t *	nodeList,
		sLUValSubBuf_t *	LUvsb,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

sGatherNRformat_loc3d()

void sGatherNRformat_loc3d	(	fact_t	Fact,
		NRformat_loc *	A,
		float *	B,
		int	ldb,
		int	nrhs,
		gridinfo3d_t *	grid3d,
		NRformat_loc3d **
	)

Here is the caller graph for this function:

sgemm_()

int sgemm_	(	const char *	,
		const char *	,
		const int *	,
		const int *	,
		const int *	,
		const float *	,
		const float *	,
		const int *	,
		const float *	,
		const int *	,
		const float *	,
		float *	,
		const int *
	)

sgemv_()

void sgemv_	(	const char *	,
		const int *	,
		const int *	,
		const float *	,
		const float *	a,
		const int *	,
		const float *	,
		const int *	,
		const float *	,
		float *	,
		const int *
	)

sGenCOOLblocks()

void sGenCOOLblocks	(	int	,
		int_t	,
		gridinfo_t *	,
		Glu_persist_t *	,
		sLocalLU_t *	,
		int_t **	,
		int_t **	,
		float **	,
		int_t *	,
		int_t *
	)

sGenCSCLblocks()

void sGenCSCLblocks	(	int	,
		int_t	,
		gridinfo_t *	,
		Glu_persist_t *	,
		sLocalLU_t *	,
		float **	,
		int_t **	,
		int_t **	,
		int_t *	,
		int_t *
	)

sGenCSRLblocks()

void sGenCSRLblocks	(	int	,
		int_t	,
		gridinfo_t *	,
		Glu_persist_t *	,
		sLocalLU_t *	,
		float **	,
		int_t **	,
		int_t **	,
		int_t *	,
		int_t *
	)

sGenXtrue_dist()

void sGenXtrue_dist	(	int_t	n,
		int_t	nrhs,
		float *	x,
		int_t	ldx
	)

Here is the caller graph for this function:

sger_()

void sger_	(	const int *	,
		const int *	,
		const float *	,
		const float *	,
		const int *	,
		const float *	,
		const int *	,
		float *	,
		const int *
	)

sgetBigU()

float * sgetBigU	(	int_t	,
		gridinfo_t *	,
		sLUstruct_t *
	)

sgetBigV()

float * sgetBigV	(	int_t	,
		int_t
	)

sgsequ_dist()

void sgsequ_dist	(	SuperMatrix *	A,
		float *	r,
		float *	c,
		float *	rowcnd,
		float *	colcnd,
		float *	amax,
		int_t *	info
	)

Purpose   
  =======   

  SGSEQU_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_S; Mtype = SLU_GE.

  R       (output) float*, size A->nrow
          If INFO = 0 or INFO > M, R contains the row scale factors   
          for A.

  C       (output) float*, size A->ncol
          If INFO = 0,  C contains the column scale factors for A.

  ROWCND  (output) float*
          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) float*
          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) float*
          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   

  ===================================================================== 

sIBcast_LPanel()

int_t sIBcast_LPanel	(	int_t	k,
		int_t	k0,
		int_t *	lsub,
		float *	lusup,
		gridinfo_t *	,
		int *	msgcnt,
		MPI_Request *	,
		int **	ToSendR,
		int_t *	xsup,
		int
	)

sIBcast_UPanel()

int_t sIBcast_UPanel	(	int_t	k,
		int_t	k0,
		int_t *	usub,
		float *	uval,
		gridinfo_t *	,
		int *	msgcnt,
		MPI_Request *	,
		int *	ToSendD,
		int
	)

sIBcastRecvLPanel()

int_t sIBcastRecvLPanel	(	int_t	k,
		int_t	k0,
		int *	msgcnt,
		MPI_Request *	,
		MPI_Request *	,
		int_t *	Lsub_buf,
		float *	Lval_buf,
		int_t *	factored,
		gridinfo_t *	,
		sLUstruct_t *	,
		SCT_t *	,
		int	tag_ub
	)

Here is the caller graph for this function:

sIBcastRecvUPanel()

int_t sIBcastRecvUPanel	(	int_t	k,
		int_t	k0,
		int *	msgcnt,
		MPI_Request *	,
		MPI_Request *	,
		int_t *	Usub_buf,
		float *	Uval_buf,
		gridinfo_t *	,
		sLUstruct_t *	,
		SCT_t *	,
		int	tag_ub
	)

Here is the caller graph for this function:

sinf_norm_error_dist()

void sinf_norm_error_dist	(	int_t	n,
		int_t	nrhs,
		float *	x,
		int_t	ldx,
		float *	xtrue,
		int_t	ldxtrue,
		gridinfo_t *	grid
	)

Check the inf-norm of the error vector.

Here is the caller graph for this function:

sinit3DLUstruct()

int_t sinit3DLUstruct	(	int_t *	myTreeIdxs,
		int_t *	myZeroTrIdxs,
		int_t *	nodeCount,
		int_t **	nodeList,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

sinit3DLUstructForest()

void sinit3DLUstructForest	(	int_t *	myTreeIdxs,
		int_t *	myZeroTrIdxs,
		sForest_t **	sForests,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

sInit_HyP()

void sInit_HyP	(	HyP_t *	HyP,
		sLocalLU_t *	Llu,
		int_t	mcb,
		int_t	mrb
	)

Here is the caller graph for this function:

sinitDiagFactBufs()

int_t sinitDiagFactBufs	(	int_t	ldt,
		sdiagFactBufs_t *	dFBuf
	)

Here is the caller graph for this function:

sinitDiagFactBufsArr()

sdiagFactBufs_t ** sinitDiagFactBufsArr	(	int_t	mxLeafNode,
		int_t	ldt,
		gridinfo_t *	grid
	)

Here is the caller graph for this function:

sinitScuBufs()

int_t sinitScuBufs	(	int_t	ldt,
		int_t	num_threads,
		int_t	nsupers,
		sscuBufs_t *	,
		sLUstruct_t *	,
		gridinfo_t *
	)

Here is the caller graph for this function:

sinitTrf3Dpartition()

trf3Dpartition_t * sinitTrf3Dpartition	(	int_t	nsupers,
		superlu_dist_options_t *	options,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

Here is the caller graph for this function:

sIRecv_LDiagBlock()

int_t sIRecv_LDiagBlock	(	int_t	k0,
		float *	L_blk_ptr,
		int_t	size,
		int_t	src,
		MPI_Request *	,
		gridinfo_t *	,
		SCT_t *	,
		int
	)

sIrecv_LPanel()

int_t sIrecv_LPanel	(	int_t	k,
		int_t	k0,
		int_t *	Lsub_buf,
		float *	Lval_buf,
		gridinfo_t *	,
		MPI_Request *	,
		sLocalLU_t *	,
		int
	)

sIRecv_UDiagBlock()

int_t sIRecv_UDiagBlock	(	int_t	k0,
		float *	ublk_ptr,
		int_t	size,
		int_t	src,
		MPI_Request *	,
		gridinfo_t *	,
		SCT_t *	,
		int
	)

sIrecv_UPanel()

int_t sIrecv_UPanel	(	int_t	k,
		int_t	k0,
		int_t *	Usub_buf,
		float *	,
		sLocalLU_t *	,
		gridinfo_t *	,
		MPI_Request *	,
		int
	)

sISend_LDiagBlock()

int_t sISend_LDiagBlock	(	int_t	k0,
		float *	lblk_ptr,
		int_t	size,
		MPI_Request *	,
		gridinfo_t *	,
		int
	)

sISend_UDiagBlock()

int_t sISend_UDiagBlock	(	int_t	k0,
		float *	ublk_ptr,
		int_t	size,
		MPI_Request *	,
		gridinfo_t *	,
		int
	)

Here is the caller graph for this function:

slangs_dist()

float slangs_dist	(	char *	norm,
		SuperMatrix *	A
	)

Purpose   
  =======   

  SLANGS_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   
  ===========   

  SLANGE returns the value   

     SLANGE = ( 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 SLANGE as described above.   
  A       (input) SuperMatrix*
          The M by N sparse matrix A. 

 =====================================================================

slaqgs_dist()

void slaqgs_dist	(	SuperMatrix *	A,
		float *	r,
		float *	c,
		float	rowcnd,
		float	colcnd,
		float	amax,
		char *	equed
	)

  Purpose   
  =======   

  SLAQGS_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_S; Mtype = GE.

  R       (input) float*, dimension (A->nrow)
          The row scale factors for A.

  C       (input) float*, dimension (A->ncol)
          The column scale factors for A.

  ROWCND  (input) float
          Ratio of the smallest R(i) to the largest R(i).

  COLCND  (input) float
          Ratio of the smallest C(i) to the largest C(i).

  AMAX    (input) float
          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.   

  ===================================================================== 

sldperm_dist()

int sldperm_dist	(	int	job,
		int	n,
		int_t	nnz,
		int_t	colptr[],
		int_t	adjncy[],
		float	nzval[],
		int_t *	perm,
		float	u[],
		float	v[]
	)

Purpose
=======

  SLDPERM 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) float*, 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) float*, of size n
       If job = 5, the natural logarithms of the row scaling factors.

v      (output) float*, 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).

sLluBufFreeArr()

int sLluBufFreeArr	(	int_t	numLA,
		sLUValSubBuf_t **	LUvsbs
	)

Here is the caller graph for this function:

sLluBufInit()

int_t sLluBufInit	(	sLUValSubBuf_t *	,
		sLUstruct_t *
	)

sLluBufInitArr()

sLUValSubBuf_t ** sLluBufInitArr	(	int_t	numLA,
		sLUstruct_t *	LUstruct
	)

Here is the caller graph for this function:

sLPanelTrSolve()

int_t sLPanelTrSolve	(	int_t	k,
		int_t *	factored_L,
		float *	BlockUFactor,
		gridinfo_t *	,
		sLUstruct_t *
	)

Here is the caller graph for this function:

sLPanelUpdate()

int_t sLPanelUpdate	(	int_t	k,
		int_t *	IrecvPlcd_D,
		int_t *	factored_L,
		MPI_Request *	,
		float *	BlockUFactor,
		gridinfo_t *	,
		sLUstruct_t *	,
		SCT_t *
	)

Here is the caller graph for this function:

sLpanelUpdate()

int_t sLpanelUpdate	(	int_t	off0,
		int_t	nsupc,
		float *	ublk_ptr,
		int_t	ld_ujrow,
		float *	lusup,
		int_t	nsupr,
		SCT_t *
	)

slsum_bmod()

void slsum_bmod	(	float *	lsum,
		float *	x,
		float *	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,
		sLocalLU_t *	Llu,
		MPI_Request	send_req[],
		SuperLUStat_t *	stat
	)

slsum_bmod_inv()

void slsum_bmod_inv	(	float *	lsum,
		float *	x,
		float *	xk,
		float *	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,
		sLocalLU_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
	)

slsum_bmod_inv_master()

void slsum_bmod_inv_master	(	float *	lsum,
		float *	x,
		float *	xk,
		float *	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,
		sLocalLU_t *	Llu,
		SuperLUStat_t **	stat,
		int_t	sizelsum,
		int_t	sizertemp,
		int	thread_id,
		int	num_thread
	)

slsum_fmod()

void slsum_fmod	(	float *	lsum,
		float *	x,
		float *	xk,
		float *	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,
		sLocalLU_t *	Llu,
		MPI_Request	send_req[],
		SuperLUStat_t *	stat
	)

Purpose
=======
  Perform local block modifications: lsum[i] -= L_i,k * X[k].

slsum_fmod_inv()

void slsum_fmod_inv	(	float *	lsum,
		float *	x,
		float *	xk,
		float *	rtemp,
		int	nrhs,
		int_t	k,
		int *	fmod,
		int_t *	xsup,
		gridinfo_t *	grid,
		sLocalLU_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].

slsum_fmod_inv_master()

void slsum_fmod_inv_master	(	float *	lsum,
		float *	x,
		float *	xk,
		float *	rtemp,
		int	nrhs,
		int	knsupc,
		int_t	k,
		int *	fmod,
		int_t	nlb,
		int_t *	xsup,
		gridinfo_t *	grid,
		sLocalLU_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].

sLUstructFree()

void sLUstructFree

(

sLUstruct_t *

LUstruct

)

Deallocate LUstruct.

sLUstructInit()

void sLUstructInit	(	const	int_t,
		sLUstruct_t *	LUstruct
	)

Allocate storage in LUstruct.

sp3dCollect()

int_t sp3dCollect	(	int_t	layer,
		int_t	n,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

sp3dScatter()

int_t sp3dScatter	(	int_t	n,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

Here is the caller graph for this function:

sp_sgemm_dist()

int sp_sgemm_dist	(	char *	transa,
		int	n,
		float	alpha,
		SuperMatrix *	A,
		float *	b,
		int	ldb,
		float	beta,
		float *	c,
		int	ldc
	)

  Purpose   
    =======   

    sp_sgemm_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) float
             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_S; Mtype = GE. 
             In the future, more general A can be handled.

    B      - float 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) float
             On entry, BETA specifies the scalar beta. When BETA is   
             supplied as zero then C need not be set on input.   

    C      - float 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.  

sp_sgemv_dist()

int sp_sgemv_dist	(	char *	trans,
		float	alpha,
		SuperMatrix *	A,
		float *	x,
		int	incx,
		float	beta,
		float *	y,
		int	incy
	)

SpGEMV.

     Purpose
     =======

     sp_strsv_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_S, 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_S, Mtype = SLU_TRU.

     x       - (input/output) float*
               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.
   
 */
int
sp_strsv_dist(char *uplo, char *trans, char *diag, SuperMatrix *L, 
          SuperMatrix *U, float *x, int *info)
{




    SCformat *Lstore;
    NCformat *Ustore;
    float   *Lval, *Uval;
    int incx = 1, incy = 1;
    float alpha = 1.0, beta = 1.0;
    int nrow;
    int fsupc, nsupr, nsupc, luptr, istart, irow;
    int i, k, iptr, jcol;
    float *work;
    flops_t solve_ops;
    /*extern SuperLUStat_t SuperLUStat;*/

    /* Test the input parameters */
    *info = 0;
    if ( strncmp(uplo,"L",1) != 0 && strncmp(uplo, "U",1) !=0 ) *info = -1;
    else if ( strncmp(trans, "N",1) !=0 && strncmp(trans, "T", 1) !=0 )
    *info = -2;
    else if ( strncmp(diag, "U", 1) !=0 && strncmp(diag, "N", 1) != 0 )
    *info = -3;
    else if ( L->nrow != L->ncol || L->nrow < 0 ) *info = -4;
    else if ( U->nrow != U->ncol || U->nrow < 0 ) *info = -5;
    if ( *info ) {
    i = -(*info);
    xerr_dist("sp_strsv_dist", &i);
    return 0;
    }

    Lstore = (SCformat *) L->Store;
    Lval = (float *) Lstore->nzval;
    Ustore = (NCformat *) U->Store;
    Uval = (float *) Ustore->nzval;
    solve_ops = 0;

    if ( !(work = floatCalloc_dist(L->nrow)) )
    ABORT("Malloc fails for work in sp_dtrsv_dist().");

    if ( strncmp(trans, "N", 1)==0 ) {  /* Form x := inv(A)*x. */

    if ( strncmp(uplo, "L", 1)==0 ) {
        /* Form x := inv(L)*x */
            if ( L->nrow == 0 ) return 0; /* Quick return */

        for (k = 0; k <= Lstore->nsuper; k++) {
        fsupc = SuperLU_L_FST_SUPC(k);
        istart = SuperLU_L_SUB_START(fsupc);
        nsupr = SuperLU_L_SUB_START(fsupc+1) - istart;
        nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
        luptr = SuperLU_L_NZ_START(fsupc);
        nrow = nsupr - nsupc;
            solve_ops += nsupc * (nsupc - 1);
            solve_ops += 2 * nrow * nsupc;
        if ( nsupc == 1 ) {
            for (iptr=istart+1; iptr < SuperLU_L_SUB_START(fsupc+1); ++iptr) {
            irow = SuperLU_L_SUB(iptr);
            ++luptr;
            x[irow] -= x[fsupc] * Lval[luptr];
            }
        } else {


















            slsolve (nsupr, nsupc, &Lval[luptr], &x[fsupc]);

            smatvec (nsupr, nsupr-nsupc, nsupc, &Lval[luptr+nsupc],
            &x[fsupc], &work[0] );


            iptr = istart + nsupc;
            for (i = 0; i < nrow; ++i, ++iptr) {
            irow = SuperLU_L_SUB(iptr);
            x[irow] -= work[i]; /* Scatter */
            work[i] = 0.0;
            }
        }
        } /* for k ... */

    } else {
        /* Form x := inv(U)*x */

        if ( U->nrow == 0 ) return 0; /* Quick return */

        for (k = Lstore->nsuper; k >= 0; k--) {
            fsupc = SuperLU_L_FST_SUPC(k);
            nsupr = SuperLU_L_SUB_START(fsupc+1) - SuperLU_L_SUB_START(fsupc);
            nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
            luptr = SuperLU_L_NZ_START(fsupc);
                solve_ops += nsupc * (nsupc + 1);

        if ( nsupc == 1 ) {
            x[fsupc] /= Lval[luptr];
            for (i = SuperLU_U_NZ_START(fsupc); i < SuperLU_U_NZ_START(fsupc+1); ++i) {
            irow = SuperLU_U_SUB(i);
            x[irow] -= x[fsupc] * Uval[i];
            }

        } else {











            susolve ( nsupr, nsupc, &Lval[luptr], &x[fsupc] );


            for (jcol = fsupc; jcol < SuperLU_L_FST_SUPC(k+1); jcol++) {
                solve_ops += 2*(SuperLU_U_NZ_START(jcol+1) - SuperLU_U_NZ_START(jcol));
                for (i = SuperLU_U_NZ_START(jcol); i < SuperLU_U_NZ_START(jcol+1); 
                i++) {
                irow = SuperLU_U_SUB(i);
                x[irow] -= x[jcol] * Uval[i];
                }
                    }
        }
        } /* for k ... */

    }
    } else { /* Form x := inv(A')*x */

    if ( strncmp(uplo, "L", 1)==0 ) {
        /* Form x := inv(L')*x */
            if ( L->nrow == 0 ) return 0; /* Quick return */

        for (k = Lstore->nsuper; k >= 0; --k) {
            fsupc = SuperLU_L_FST_SUPC(k);
            istart = SuperLU_L_SUB_START(fsupc);
            nsupr = SuperLU_L_SUB_START(fsupc+1) - istart;
            nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
            luptr = SuperLU_L_NZ_START(fsupc);

        solve_ops += 2 * (nsupr - nsupc) * nsupc;
        for (jcol = fsupc; jcol < SuperLU_L_FST_SUPC(k+1); jcol++) {
            iptr = istart + nsupc;
            for (i = SuperLU_L_NZ_START(jcol) + nsupc; 
                i < SuperLU_L_NZ_START(jcol+1); i++) {
            irow = SuperLU_L_SUB(iptr);
            x[jcol] -= x[irow] * Lval[i];
            iptr++;
            }
        }

        if ( nsupc > 1 ) {
            solve_ops += nsupc * (nsupc - 1);













            strsv_("L", "T", "U", &nsupc, &Lval[luptr], &nsupr,
            &x[fsupc], &incx);

        }
        }
    } else {
        /* Form x := inv(U')*x */
        if ( U->nrow == 0 ) return 0; /* Quick return */

        for (k = 0; k <= Lstore->nsuper; k++) {
            fsupc = SuperLU_L_FST_SUPC(k);
            nsupr = SuperLU_L_SUB_START(fsupc+1) - SuperLU_L_SUB_START(fsupc);
            nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
            luptr = SuperLU_L_NZ_START(fsupc);

        for (jcol = fsupc; jcol < SuperLU_L_FST_SUPC(k+1); jcol++) {
            solve_ops += 2*(SuperLU_U_NZ_START(jcol+1) - SuperLU_U_NZ_START(jcol));
            for (i = SuperLU_U_NZ_START(jcol); i < SuperLU_U_NZ_START(jcol+1); i++) {
            irow = SuperLU_U_SUB(i);
            x[jcol] -= x[irow] * Uval[i];
            }
        }

        solve_ops += nsupc * (nsupc + 1);
        if ( nsupc == 1 ) {
            x[fsupc] /= Lval[luptr];
        } else {












            strsv_("U", "T", "N", &nsupc, &Lval[luptr], &nsupr,
                &x[fsupc], &incx);

        }
        } /* for k ... */
    }
    }

    /*SuperLUStat.ops[SOLVE] += solve_ops;*/
    SUPERLU_FREE(work);
    return 0;
} /* sp_strsv_dist */


/*!
  Purpose   
    =======   

    sp_sgemv_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_S; Mtype = SLU_GE. 
             In the future, more general A can be handled.

    X      - (input) float*, 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) float
             On entry, BETA specifies the scalar beta. When BETA is   
             supplied as zero then Y need not be set on input.   

    Y      - (output) float*,  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.   

  Purpose   
    =======   

    sp_sgemv_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_S; Mtype = SLU_GE. 
             In the future, more general A can be handled.

    X      - (input) float*, 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) float
             On entry, BETA specifies the scalar beta. When BETA is   
             supplied as zero then Y need not be set on input.   

    Y      - (output) float*,  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.   
 

sp_strsv_dist()

int sp_strsv_dist	(	char *	uplo,
		char *	trans,
		char *	diag,
		SuperMatrix *	L,
		SuperMatrix *	U,
		float *	x,
		int *	info
	)

  Purpose
  =======

  sp_strsv_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_S, 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_S, Mtype = SLU_TRU.

  x       - (input/output) float*
            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:

sPackLBlock()

int_t sPackLBlock	(	int_t	k,
		float *	Dest,
		Glu_persist_t *	,
		gridinfo_t *	,
		sLocalLU_t *
	)

sPrint_CompCol_Matrix_dist()

void sPrint_CompCol_Matrix_dist

(

SuperMatrix *

)

Here is the caller graph for this function:

sPrint_CompRowLoc_Matrix_dist()

int sPrint_CompRowLoc_Matrix_dist

(

SuperMatrix *

)

sPrint_Dense_Matrix_dist()

void sPrint_Dense_Matrix_dist

(

SuperMatrix *

)

sPrintLblocks()

void sPrintLblocks	(	int	iam,
		int_t	nsupers,
		gridinfo_t *	grid,
		Glu_persist_t *	Glu_persist,
		sLocalLU_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:

sPrintUblocks()

void sPrintUblocks	(	int	iam,
		int_t	nsupers,
		gridinfo_t *	grid,
		Glu_persist_t *	Glu_persist,
		sLocalLU_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:

sQuerySpace_dist()

int_t sQuerySpace_dist	(	int_t	n,
		sLUstruct_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.

sread_binary()

int sread_binary	(	FILE *	fp,
		int_t *	m,
		int_t *	n,
		int_t *	nnz,
		float **	nzval,
		int_t **	rowind,
		int_t **	colptr
	)

sreadhb_dist()

void sreadhb_dist	(	int	iam,
		FILE *	fp,
		int_t *	nrow,
		int_t *	ncol,
		int_t *	nonz,
		float **	nzval,
		int_t **	rowind,
		int_t **	colptr
	)

Purpose
=======

Read a FLOAT 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)

sreadMM_dist()

void sreadMM_dist	(	FILE *	fp,
		int_t *	m,
		int_t *	n,
		int_t *	nonz,
		float **	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.

sreadrb_dist()

void sreadrb_dist	(	int	iam,
		FILE *	fp,
		int_t *	nrow,
		int_t *	ncol,
		int_t *	nonz,
		float **	nzval,
		int_t **	rowind,
		int_t **	colptr
	)

sreadtriple_dist()

void sreadtriple_dist	(	FILE *	fp,
		int_t *	m,
		int_t *	n,
		int_t *	nonz,
		float **	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.

sreadtriple_noheader()

void sreadtriple_noheader	(	FILE *	fp,
		int_t *	m,
		int_t *	n,
		int_t *	nonz,
		float **	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.

sRecv_UDiagBlock()

int_t sRecv_UDiagBlock	(	int_t	k0,
		float *	ublk_ptr,
		int_t	size,
		int_t	src,
		gridinfo_t *	,
		SCT_t *	,
		int
	)

Here is the caller graph for this function:

sreduceAllAncestors3d()

int sreduceAllAncestors3d	(	int_t	ilvl,
		int_t *	myNodeCount,
		int_t **	treePerm,
		sLUValSubBuf_t *	LUvsb,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

Here is the caller graph for this function:

sreduceAncestors3d()

int_t sreduceAncestors3d	(	int_t	sender,
		int_t	receiver,
		int_t	nnodes,
		int_t *	nodeList,
		float *	Lval_buf,
		float *	Uval_buf,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

sRgather_L()

void sRgather_L	(	int_t	k,
		int_t *	lsub,
		float *	lusup,
		gEtreeInfo_t *	,
		Glu_persist_t *	,
		gridinfo_t *	,
		HyP_t *	,
		int_t *	myIperm,
		int_t *	iperm_c_supno
	)

sRgather_U()

void sRgather_U	(	int_t	k,
		int_t	jj0,
		int_t *	usub,
		float *	uval,
		float *	bigU,
		gEtreeInfo_t *	,
		Glu_persist_t *	,
		gridinfo_t *	,
		HyP_t *	,
		int_t *	myIperm,
		int_t *	iperm_c_supno,
		int_t *	perm_u
	)

sscal_()

int sscal_	(	const int *	n,
		const float *	alpha,
		float *	dx,
		const int *	incx
	)

sScaleAdd_CompRowLoc_Matrix_dist()

void sScaleAdd_CompRowLoc_Matrix_dist	(	SuperMatrix *	A,
		SuperMatrix *	B,
		float	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.

sScaleAddId_CompRowLoc_Matrix_dist()

void sScaleAddId_CompRowLoc_Matrix_dist	(	SuperMatrix *	A,
		float	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:

sScalePermstructFree()

void sScalePermstructFree

(

sScalePermstruct_t *

ScalePermstruct

)

Deallocate ScalePermstruct.

Here is the caller graph for this function:

sScalePermstructInit()

void sScalePermstructInit	(	const	int_t,
		const	int_t,
		sScalePermstruct_t *	ScalePermstruct
	)

Allocate storage in ScalePermstruct.

Here is the call graph for this function:

Here is the caller graph for this function:

sscatter3dLPanels()

int_t sscatter3dLPanels	(	int_t	nsupers,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

sscatter3dUPanels()

int_t sscatter3dUPanels	(	int_t	nsupers,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d
	)

sScatter_B3d()

int sScatter_B3d	(	NRformat_loc3d *	A3d,
		gridinfo3d_t *	grid3d
	)

Here is the caller graph for this function:

sscatter_l()

void sscatter_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,
		float *	tempv,
		int *	indirect_thread,
		int *	indirect2,
		int_t **	Lrowind_bc_ptr,
		float **	Lnzval_bc_ptr,
		gridinfo_t *	grid
	)

sscatter_u()

void sscatter_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,
		float *	tempv,
		int_t **	Ufstnz_br_ptr,
		float **	Unzval_br_ptr,
		gridinfo_t *	grid
	)

sSchurComplementSetup()

int_t sSchurComplementSetup	(	int_t	k,
		int *	msgcnt,
		Ublock_info_t *	,
		Remain_info_t *	,
		uPanelInfo_t *	,
		lPanelInfo_t *	,
		int_t *	,
		int_t *	,
		int_t *	,
		float *	bigU,
		int_t *	Lsub_buf,
		float *	Lval_buf,
		int_t *	Usub_buf,
		float *	Uval_buf,
		gridinfo_t *	,
		sLUstruct_t *
	)

sSchurComplementSetupGPU()

int_t sSchurComplementSetupGPU	(	int_t	k,
		msgs_t *	msgs,
		packLUInfo_t *	,
		int_t *	,
		int_t *	,
		int_t *	,
		gEtreeInfo_t *	,
		factNodelists_t *	,
		sscuBufs_t *	,
		sLUValSubBuf_t *	LUvsb,
		gridinfo_t *	,
		sLUstruct_t *	,
		HyP_t *
	)

sSolveFinalize()

void sSolveFinalize	(	superlu_dist_options_t *	options,
		sSOLVEstruct_t *	SOLVEstruct
	)

Release the resources used for the solution phase.

sSolveInit()

int sSolveInit	(	superlu_dist_options_t *	options,
		SuperMatrix *	A,
		int_t	perm_r[],
		int_t	perm_c[],
		int_t	nrhs,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid,
		sSOLVEstruct_t *	SOLVEstruct
	)

Initialize the data structure for the solution phase.

ssparseTreeFactor()

int_t ssparseTreeFactor	(	int_t	nnodes,
		int_t *	perm_c_supno,
		treeTopoInfo_t *	treeTopoInfo,
		commRequests_t *	comReqs,
		sscuBufs_t *	scuBufs,
		packLUInfo_t *	packLUInfo,
		msgs_t *	msgs,
		sLUValSubBuf_t *	LUvsb,
		sdiagFactBufs_t *	dFBuf,
		factStat_t *	factStat,
		factNodelists_t *	fNlists,
		superlu_dist_options_t *	options,
		int_t *	gIperm_c_supno,
		int_t	ldt,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SuperLUStat_t *	stat,
		double	thresh,
		SCT_t *	SCT,
		int *	info
	)

ssparseTreeFactor_ASYNC()

int_t ssparseTreeFactor_ASYNC	(	sForest_t *	sforest,
		commRequests_t **	comReqss,
		sscuBufs_t *	scuBufs,
		packLUInfo_t *	packLUInfo,
		msgs_t **	msgss,
		sLUValSubBuf_t **	LUvsbs,
		sdiagFactBufs_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,
		sLUstruct_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:

sstatic_schedule()

int sstatic_schedule	(	superlu_dist_options_t *	options,
		int	m,
		int	n,
		sLUstruct_t *	LUstruct,
		gridinfo_t *	grid,
		SuperLUStat_t *	stat,
		int_t *	perm_c_supno,
		int_t *	iperm_c_supno,
		int *	info
	)

sTrs2_GatherTrsmScatter()

int_t sTrs2_GatherTrsmScatter	(	int_t	klst,
		int_t	iukp,
		int_t	rukp,
		int_t *	usub,
		float *	uval,
		float *	tempv,
		int_t	knsupc,
		int	nsupr,
		float *	lusup,
		Glu_persist_t *	Glu_persist
	)

sTrs2_GatherU()

int_t sTrs2_GatherU	(	int_t	iukp,
		int_t	rukp,
		int_t	klst,
		int_t	nsupc,
		int_t	ldu,
		int_t *	usub,
		float *	uval,
		float *	tempv
	)

sTrs2_ScatterU()

int_t sTrs2_ScatterU	(	int_t	iukp,
		int_t	rukp,
		int_t	klst,
		int_t	nsupc,
		int_t	ldu,
		int_t *	usub,
		float *	uval,
		float *	tempv
	)

strsm_()

int strsm_	(	const char *	,
		const char *	,
		const char *	,
		const char *	,
		const int *	,
		const int *	,
		const float *	,
		const float *	,
		const int *	,
		float *	,
		const int *
	)

strsv_()

int strsv_	(	char *	,
		char *	,
		char *	,
		int *	,
		float *	,
		int *	,
		float *	,
		int *
	)

sUDiagBlockRecvWait()

int_t sUDiagBlockRecvWait	(	int_t	k,
		int_t *	IrecvPlcd_D,
		int_t *	factored_L,
		MPI_Request *	,
		gridinfo_t *	,
		sLUstruct_t *	,
		SCT_t *
	)

sUPanelTrSolve()

int_t sUPanelTrSolve	(	int_t	k,
		float *	BlockLFactor,
		float *	bigV,
		int_t	ldt,
		Ublock_info_t *	,
		gridinfo_t *	,
		sLUstruct_t *	,
		SuperLUStat_t *	,
		SCT_t *
	)

Here is the caller graph for this function:

sUPanelUpdate()

int_t sUPanelUpdate	(	int_t	k,
		int_t *	factored_U,
		MPI_Request *	,
		float *	BlockLFactor,
		float *	bigV,
		int_t	ldt,
		Ublock_info_t *	,
		gridinfo_t *	,
		sLUstruct_t *	,
		SuperLUStat_t *	,
		SCT_t *
	)

Here is the caller graph for this function:

superlu_saxpy()

int superlu_saxpy	(	const int	n,
		const float	alpha,
		const float *	x,
		const int	incx,
		float *	y,
		const int	incy
	)

superlu_sgemm()

int superlu_sgemm	(	const char *	transa,
		const char *	transb,
		int	m,
		int	n,
		int	k,
		float	alpha,
		float *	a,
		int	lda,
		float *	b,
		int	ldb,
		float	beta,
		float *	c,
		int	ldc
	)

superlu_sgemv()

int superlu_sgemv	(	const char *	trans,
		const int	m,
		const int	n,
		const float	alpha,
		const float *	a,
		const int	lda,
		const float *	x,
		const int	incx,
		const float	beta,
		float *	y,
		const int	incy
	)

superlu_sger()

int superlu_sger	(	const int	m,
		const int	n,
		const float	alpha,
		const float *	x,
		const int	incx,
		const float *	y,
		const int	incy,
		float *	a,
		const int	lda
	)

superlu_sscal()

int superlu_sscal	(	const int	n,
		const float	alpha,
		float *	x,
		const int	incx
	)

superlu_strsm()

int superlu_strsm	(	const char *	sideRL,
		const char *	uplo,
		const char *	transa,
		const char *	diag,
		const int	m,
		const int	n,
		const float	alpha,
		const float *	a,
		const int	lda,
		float *	b,
		const int	ldb
	)

Here is the caller graph for this function:

superlu_strsv()

int superlu_strsv	(	char *	uplo,
		char *	trans,
		char *	diag,
		int	n,
		float *	a,
		int	lda,
		float *	x,
		int	incx
	)

sWait_LRecv()

int_t sWait_LRecv	(	MPI_Request *	,
		int *	msgcnt,
		int *	msgcntsU,
		gridinfo_t *	,
		SCT_t *
	)

sWait_URecv()

int_t sWait_URecv	(	MPI_Request *	,
		int *	msgcnt,
		SCT_t *
	)

sWaitL()

int_t sWaitL	(	int_t	k,
		int *	msgcnt,
		int *	msgcntU,
		MPI_Request *	,
		MPI_Request *	,
		gridinfo_t *	,
		sLUstruct_t *	,
		SCT_t *
	)

Here is the caller graph for this function:

sWaitU()

int_t sWaitU	(	int_t	k,
		int *	msgcnt,
		MPI_Request *	,
		MPI_Request *	,
		gridinfo_t *	,
		sLUstruct_t *	,
		SCT_t *
	)

Here is the caller graph for this function:

sZero_CompRowLoc_Matrix_dist()

void sZero_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:

sZeroLblocks()

void sZeroLblocks	(	int	iam,
		int	n,
		gridinfo_t *	grid,
		sLUstruct_t *	LUstruct
	)

Sets all entries of matrix L to zero.

Here is the caller graph for this function:

szeroSetLU()

int_t szeroSetLU	(	int_t	nnodes,
		int_t *	nodeList,
		sLUstruct_t *	,
		gridinfo3d_t *
	)

sZeroUblocks()

void sZeroUblocks	(	int	iam,
		int	n,
		gridinfo_t *	grid,
		sLUstruct_t *	LUstruct
	)

Sets all entries of matrix U to zero.

Here is the caller graph for this function:

szRecvLPanel()

int_t szRecvLPanel	(	int_t	k,
		int_t	sender,
		float	alpha,
		float	beta,
		float *	Lval_buf,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

szRecvUPanel()

int_t szRecvUPanel	(	int_t	k,
		int_t	sender,
		float	alpha,
		float	beta,
		float *	Uval_buf,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

szSendLPanel()

int_t szSendLPanel	(	int_t	k,
		int_t	receiver,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

szSendUPanel()

int_t szSendUPanel	(	int_t	k,
		int_t	receiver,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SCT_t *	SCT
	)

treeFactor()

int_t treeFactor	(	int_t	nnnodes,
		int_t *	perm_c_supno,
		commRequests_t *	comReqs,
		sscuBufs_t *	scuBufs,
		packLUInfo_t *	packLUInfo,
		msgs_t *	msgs,
		sLUValSubBuf_t *	LUvsb,
		sdiagFactBufs_t *	dFBuf,
		factStat_t *	factStat,
		factNodelists_t *	fNlists,
		superlu_dist_options_t *	options,
		int_t *	gIperm_c_supno,
		int_t	ldt,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SuperLUStat_t *	stat,
		double	thresh,
		SCT_t *	SCT,
		int *	info
	)

updateDirtyBit()

int updateDirtyBit	(	int_t	k0,
		HyP_t *	HyP,
		gridinfo_t *	grid
	)