271 lines
10 KiB
C
271 lines
10 KiB
C
/** \file opennl/superlu/util.h
|
|
* \ingroup opennl
|
|
*/
|
|
#ifndef __SUPERLU_UTIL /* allow multiple inclusions */
|
|
#define __SUPERLU_UTIL
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
/*
|
|
#ifndef __STDC__
|
|
#include <malloc.h>
|
|
#endif
|
|
*/
|
|
#include <assert.h>
|
|
|
|
/***********************************************************************
|
|
* Macros
|
|
***********************************************************************/
|
|
#define FIRSTCOL_OF_SNODE(i) (xsup[i])
|
|
/* No of marker arrays used in the symbolic factorization,
|
|
each of size n */
|
|
#define NO_MARKER 3
|
|
#define NUM_TEMPV(m,w,t,b) ( SUPERLU_MAX(m, (t + b)*w) )
|
|
|
|
#ifndef USER_ABORT
|
|
#define USER_ABORT(msg) superlu_abort_and_exit(msg)
|
|
#endif
|
|
|
|
#define ABORT(err_msg) \
|
|
{ char msg[256];\
|
|
sprintf(msg,"%s at line %d in file %s\n",err_msg,__LINE__, __FILE__);\
|
|
USER_ABORT(msg); }
|
|
|
|
|
|
#ifndef USER_MALLOC
|
|
#if 1
|
|
#define USER_MALLOC(size) superlu_malloc(size)
|
|
#else
|
|
/* The following may check out some uninitialized data */
|
|
#define USER_MALLOC(size) memset (superlu_malloc(size), '\x0F', size)
|
|
#endif
|
|
#endif
|
|
|
|
#define SUPERLU_MALLOC(size) USER_MALLOC(size)
|
|
|
|
#ifndef USER_FREE
|
|
#define USER_FREE(addr) superlu_free(addr)
|
|
#endif
|
|
|
|
#define SUPERLU_FREE(addr) USER_FREE(addr)
|
|
|
|
#define CHECK_MALLOC(where) { \
|
|
extern int superlu_malloc_total; \
|
|
printf("%s: malloc_total %d Bytes\n", \
|
|
where, superlu_malloc_total); \
|
|
}
|
|
|
|
#define SUPERLU_MAX(x, y) ( (x) > (y) ? (x) : (y) )
|
|
#define SUPERLU_MIN(x, y) ( (x) < (y) ? (x) : (y) )
|
|
|
|
/***********************************************************************
|
|
* Constants
|
|
***********************************************************************/
|
|
#define EMPTY (-1)
|
|
/*#define NO (-1)*/
|
|
#define FALSE 0
|
|
#define TRUE 1
|
|
|
|
/***********************************************************************
|
|
* Enumerate types
|
|
***********************************************************************/
|
|
typedef enum {NO, YES} yes_no_t;
|
|
typedef enum {DOFACT, SamePattern, SamePattern_SameRowPerm, FACTORED} fact_t;
|
|
typedef enum {NOROWPERM, LargeDiag, MY_PERMR} rowperm_t;
|
|
typedef enum {NATURAL, MMD_ATA, MMD_AT_PLUS_A, COLAMD, MY_PERMC}colperm_t;
|
|
typedef enum {NOTRANS, TRANS, CONJ} trans_t;
|
|
typedef enum {NOEQUIL, ROW, COL, BOTH} DiagScale_t;
|
|
typedef enum {NOREFINE, SINGLE=1, SLU_DOUBLE, EXTRA} IterRefine_t;
|
|
typedef enum {LUSUP, UCOL, LSUB, USUB} MemType;
|
|
typedef enum {HEAD, TAIL} stack_end_t;
|
|
typedef enum {SYSTEM, USER} LU_space_t;
|
|
|
|
/*
|
|
* The following enumerate type is used by the statistics variable
|
|
* to keep track of flop count and time spent at various stages.
|
|
*
|
|
* Note that not all of the fields are disjoint.
|
|
*/
|
|
typedef enum {
|
|
COLPERM, /* find a column ordering that minimizes fills */
|
|
RELAX, /* find artificial supernodes */
|
|
ETREE, /* compute column etree */
|
|
EQUIL, /* equilibrate the original matrix */
|
|
FACT, /* perform LU factorization */
|
|
RCOND, /* estimate reciprocal condition number */
|
|
SOLVE, /* forward and back solves */
|
|
REFINE, /* perform iterative refinement */
|
|
SLU_FLOAT, /* time spent in floating-point operations */
|
|
TRSV, /* fraction of FACT spent in xTRSV */
|
|
GEMV, /* fraction of FACT spent in xGEMV */
|
|
FERR, /* estimate error bounds after iterative refinement */
|
|
NPHASES /* total number of phases */
|
|
} PhaseType;
|
|
|
|
|
|
/***********************************************************************
|
|
* Type definitions
|
|
***********************************************************************/
|
|
typedef float flops_t;
|
|
typedef unsigned char Logical;
|
|
|
|
/*
|
|
*-- This contains the options used to control the solve process.
|
|
*
|
|
* Fact (fact_t)
|
|
* Specifies whether or not the factored form of the matrix
|
|
* A is supplied on entry, and if not, how the matrix A should
|
|
* be factorizaed.
|
|
* = DOFACT: The matrix A will be factorized from scratch, and the
|
|
* factors will be stored in L and U.
|
|
* = SamePattern: The matrix A will be factorized assuming
|
|
* that a factorization of a matrix with the same sparsity
|
|
* pattern was performed prior to this one. Therefore, this
|
|
* factorization will reuse column permutation vector
|
|
* ScalePermstruct->perm_c and the column elimination tree
|
|
* LUstruct->etree.
|
|
* = SamePattern_SameRowPerm: The matrix A will be factorized
|
|
* assuming that a factorization of a matrix with the same
|
|
* sparsity pattern and similar numerical values was performed
|
|
* prior to this one. Therefore, this factorization will reuse
|
|
* both row and column scaling factors R and C, and the
|
|
* both row and column permutation vectors perm_r and perm_c,
|
|
* distributed data structure set up from the previous symbolic
|
|
* factorization.
|
|
* = FACTORED: On entry, L, U, perm_r and perm_c contain the
|
|
* factored form of A. If DiagScale is not NOEQUIL, the matrix
|
|
* A has been equilibrated with scaling factors R and C.
|
|
*
|
|
* Equil (yes_no_t)
|
|
* Specifies whether to equilibrate the system (scale A's row and
|
|
* columns to have unit norm).
|
|
*
|
|
* ColPerm (colperm_t)
|
|
* Specifies what type of column permutation to use to reduce fill.
|
|
* = NATURAL: use the natural ordering
|
|
* = MMD_ATA: use minimum degree ordering on structure of A'*A
|
|
* = MMD_AT_PLUS_A: use minimum degree ordering on structure of A'+A
|
|
* = COLAMD: use approximate minimum degree column ordering
|
|
* = MY_PERMC: use the ordering specified in ScalePermstruct->perm_c[]
|
|
*
|
|
* Trans (trans_t)
|
|
* Specifies the form of the system of equations:
|
|
* = NOTRANS: A * X = B (No transpose)
|
|
* = TRANS: A**T * X = B (Transpose)
|
|
* = CONJ: A**H * X = B (Transpose)
|
|
*
|
|
* IterRefine (IterRefine_t)
|
|
* Specifies whether to perform iterative refinement.
|
|
* = NO: no iterative refinement
|
|
* = WorkingPrec: perform iterative refinement in working precision
|
|
* = ExtraPrec: perform iterative refinement in extra precision
|
|
*
|
|
* PrintStat (yes_no_t)
|
|
* Specifies whether to print the solver's statistics.
|
|
*
|
|
* DiagPivotThresh (double, in [0.0, 1.0]) (only for sequential SuperLU)
|
|
* Specifies the threshold used for a diagonal entry to be an
|
|
* acceptable pivot.
|
|
*
|
|
* PivotGrowth (yes_no_t)
|
|
* Specifies whether to compute the reciprocal pivot growth.
|
|
*
|
|
* ConditionNumber (ues_no_t)
|
|
* Specifies whether to compute the reciprocal condition number.
|
|
*
|
|
* RowPerm (rowperm_t) (only for SuperLU_DIST)
|
|
* Specifies whether to permute rows of the original matrix.
|
|
* = NO: not to permute the rows
|
|
* = LargeDiag: make the diagonal large relative to the off-diagonal
|
|
* = MY_PERMR: use the permutation given in ScalePermstruct->perm_r[]
|
|
*
|
|
* ReplaceTinyPivot (yes_no_t) (only for SuperLU_DIST)
|
|
* Specifies whether to replace the tiny diagonals by
|
|
* sqrt(epsilon)*||A|| during LU factorization.
|
|
*
|
|
* SolveInitialized (yes_no_t) (only for SuperLU_DIST)
|
|
* Specifies whether the initialization has been performed to the
|
|
* triangular solve.
|
|
*
|
|
* RefineInitialized (yes_no_t) (only for SuperLU_DIST)
|
|
* Specifies whether the initialization has been performed to the
|
|
* sparse matrix-vector multiplication routine needed in iterative
|
|
* refinement.
|
|
*/
|
|
typedef struct {
|
|
fact_t Fact;
|
|
yes_no_t Equil;
|
|
colperm_t ColPerm;
|
|
trans_t Trans;
|
|
IterRefine_t IterRefine;
|
|
yes_no_t PrintStat;
|
|
yes_no_t SymmetricMode;
|
|
double DiagPivotThresh;
|
|
yes_no_t PivotGrowth;
|
|
yes_no_t ConditionNumber;
|
|
rowperm_t RowPerm;
|
|
yes_no_t ReplaceTinyPivot;
|
|
yes_no_t SolveInitialized;
|
|
yes_no_t RefineInitialized;
|
|
} superlu_options_t;
|
|
|
|
typedef struct {
|
|
int *panel_histo; /* histogram of panel size distribution */
|
|
double *utime; /* running time at various phases */
|
|
flops_t *ops; /* operation count at various phases */
|
|
int TinyPivots; /* number of tiny pivots */
|
|
int RefineSteps; /* number of iterative refinement steps */
|
|
} SuperLUStat_t;
|
|
|
|
|
|
/***********************************************************************
|
|
* Prototypes
|
|
***********************************************************************/
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern void Destroy_SuperMatrix_Store(SuperMatrix *);
|
|
extern void Destroy_CompCol_Matrix(SuperMatrix *);
|
|
extern void Destroy_CompRow_Matrix(SuperMatrix *);
|
|
extern void Destroy_SuperNode_Matrix(SuperMatrix *);
|
|
extern void Destroy_CompCol_Permuted(SuperMatrix *);
|
|
extern void Destroy_Dense_Matrix(SuperMatrix *);
|
|
extern void get_perm_c(int, SuperMatrix *, int *);
|
|
extern void set_default_options(superlu_options_t *options);
|
|
extern void sp_preorder (superlu_options_t *, SuperMatrix*, int*, int*,
|
|
SuperMatrix*);
|
|
extern void superlu_abort_and_exit(char*);
|
|
extern void *superlu_malloc (size_t);
|
|
extern int *intMalloc (int);
|
|
extern int *intCalloc (int);
|
|
extern void superlu_free (void*);
|
|
extern void SetIWork (int, int, int, int *, int **, int **, int **,
|
|
int **, int **, int **, int **);
|
|
extern int sp_coletree (int *, int *, int *, int, int, int *);
|
|
extern void relax_snode (const int, int *, const int, int *, int *);
|
|
extern void heap_relax_snode (const int, int *, const int, int *, int *);
|
|
extern void resetrep_col (const int, const int *, int *);
|
|
extern int spcoletree (int *, int *, int *, int, int, int *);
|
|
extern int *TreePostorder (int, int *);
|
|
extern double SuperLU_timer_ (void);
|
|
extern int sp_ienv (int);
|
|
extern int lsame_ (char *, char *);
|
|
extern int xerbla_ (char *, int *);
|
|
extern void ifill (int *, int, int);
|
|
extern void snode_profile (int, int *);
|
|
extern void super_stats (int, int *);
|
|
extern void PrintSumm (char *, int, int, int);
|
|
extern void StatInit(SuperLUStat_t *);
|
|
extern void StatPrint (SuperLUStat_t *);
|
|
extern void StatFree(SuperLUStat_t *);
|
|
extern void print_panel_seg(int, int, int, int, int *, int *);
|
|
extern void check_repfnz(int, int, int, int *);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __SUPERLU_UTIL */
|