SRC/superlu_defs.h

Go to the documentation of this file.
00001 
00012 #ifndef __SUPERLU_DEFS /* allow multiple inclusions */
00013 #define __SUPERLU_DEFS
00014 
00015 /*
00016  * File name:   superlu_defs.h
00017  * Purpose:     Definitions which are precision-neutral
00018  */
00019 #ifdef _CRAY
00020 #include <fortran.h>
00021 #include <string.h>
00022 #endif
00023 #include <mpi.h>
00024 #include <stdlib.h>
00025 #include <stdio.h>
00026 
00027 
00028 /* Define my integer size int_t */
00029 #ifdef _CRAY
00030 typedef short int_t;
00031 /*#undef int   Revert back to int of default size. */
00032 #define mpi_int_t   MPI_SHORT
00033 #elif defined (_LONGINT)
00034 typedef long int int_t;
00035 #define mpi_int_t   MPI_LONG
00036 #else /* Default */
00037 typedef int int_t;
00038 #define mpi_int_t   MPI_INT
00039 #endif
00040 
00041 /***********************************************************************
00042  * Enumerated types
00043  ***********************************************************************/
00044 /*typedef enum {FALSE, TRUE}                                      boolean_t;*/
00045 typedef enum {NO, YES}                                          yes_no_t;
00046 typedef enum {DOFACT, SamePattern, SamePattern_SameRowPerm, FACTORED} fact_t;
00047 typedef enum {NOROWPERM, LargeDiag, MY_PERMR}                   rowperm_t;
00048 typedef enum {NATURAL, MMD_AT_PLUS_A, MMD_ATA, METIS_AT_PLUS_A,
00049               PARMETIS, MY_PERMC}                               colperm_t;
00050 typedef enum {NOTRANS, TRANS, CONJ}                             trans_t;
00051 typedef enum {NOEQUIL, ROW, COL, BOTH}                          DiagScale_t;
00052 typedef enum {NOREFINE, SINGLE=1, DOUBLE, EXTRA}                IterRefine_t;
00053 typedef enum {LUSUP, UCOL, LSUB, USUB}                          MemType;
00054 typedef enum {HEAD, TAIL}                                       stack_end_t;
00055 typedef enum {SYSTEM, USER}                                     LU_space_t;
00056 
00057 #include "Cnames.h"
00058 #include "supermatrix.h"
00059 #include "util_dist.h"
00060 #include "psymbfact.h"
00061 
00062 
00063 /***********************************************************************
00064  * Constants
00065  ***********************************************************************/
00066 /* 
00067  * For each block column of L, the index[] array contains both the row 
00068  * subscripts and the integers describing the size of the blocks.
00069  * The organization of index[] looks like:
00070  *
00071  *     [ BLOCK COLUMN HEADER (size BC_HEADER)
00072  *           number of blocks 
00073  *           number of row subscripts, i.e., LDA of nzval[]
00074  *       BLOCK 0                                        <----
00075  *           BLOCK DESCRIPTOR (of size LB_DESCRIPTOR)  |
00076  *               block number (global)                      |
00077  *               number of full rows in the block           |
00078  *           actual row subscripts                          |
00079  *       BLOCK 1                                            | Repeat ...
00080  *           BLOCK DESCRIPTOR                               | number of blocks
00081  *               block number (global)                      | 
00082  *               number of full rows in the block           |
00083  *           actual row subscripts                          |
00084  *       .                                                  |
00085  *       .                                                  |
00086  *       .                                              <----
00087  *     ]
00088  *
00089  * For each block row of U, the organization of index[] looks like:
00090  *
00091  *     [ BLOCK ROW HEADER (of size BR_HEADER)
00092  *           number of blocks 
00093  *           number of entries in nzval[]
00094  *           number of entries in index[]
00095  *       BLOCK 0                                        <----
00096  *           BLOCK DESCRIPTOR (of size UB_DESCRIPTOR)  |
00097  *               block number (global)                      |
00098  *               number of nonzeros in the block            |
00099  *           actual fstnz subscripts                        |
00100  *       BLOCK 1                                            | Repeat ...
00101  *           BLOCK DESCRIPTOR                               | number of blocks
00102  *               block number (global)                      |
00103  *               number of nonzeros in the block            |
00104  *           actual fstnz subscripts                        |
00105  *       .                                                  |
00106  *       .                                                  |
00107  *       .                                              <----
00108  *     ]
00109  *
00110  */
00111 #define BC_HEADER      2
00112 #define LB_DESCRIPTOR  2
00113 #define BR_HEADER      3
00114 #define UB_DESCRIPTOR  2
00115 #define NBUFFERS       5
00116 
00117 /*
00118  * Communication tags
00119  */
00120     /* For numeric factorization. */
00121 #define NTAGS    10000
00122 #define UjROW    10
00123 #define UkSUB    11
00124 #define UkVAL    12
00125 #define LkSUB    13
00126 #define LkVAL    14
00127 #define LkkDIAG  15
00128     /* For triangular solves. */
00129 #define XK_H     1  /* The header preceeding each X block. */
00130 #define LSUM_H   1  /* The header preceeding each MOD block. */
00131 #define GSUM     20 
00132 #define Xk       21
00133 #define Yk       22
00134 #define LSUM     23
00135 
00136 /* 
00137  * Communication scopes
00138  */
00139 #define COMM_ALL      100
00140 #define COMM_COLUMN   101
00141 #define COMM_ROW      102
00142 
00143 /*
00144  * Matrix distribution for sparse matrix-vector multiplication
00145  */
00146 #define SUPER_LINEAR     11
00147 #define SUPER_BLOCK      12
00148 
00149 /*
00150  * No of marker arrays used in the symbolic factorization, each of size n
00151  */
00152 #define NO_MARKER     3
00153 
00154 
00155 
00156 /***********************************************************************
00157  * Macros
00158  ***********************************************************************/
00159 #define IAM(comm)    { int rank; MPI_Comm_rank ( comm, &rank ); rank};
00160 #define MYROW(iam,grid) ( (iam) / grid->npcol )
00161 #define MYCOL(iam,grid) ( (iam) % grid->npcol )
00162 #define BlockNum(i)     ( supno[i] )
00163 #define FstBlockC(bnum) ( xsup[bnum] )
00164 #define SuperSize(bnum) ( xsup[bnum+1]-xsup[bnum] )
00165 #define LBi(bnum,grid)  ( (bnum)/grid->nprow )/* Global to local block rowwise */
00166 #define LBj(bnum,grid)  ( (bnum)/grid->npcol )/* Global to local block columnwise*/
00167 #define PROW(bnum,grid) ( (bnum) % grid->nprow )
00168 #define PCOL(bnum,grid) ( (bnum) % grid->npcol )
00169 #define PNUM(i,j,grid)  ( (i)*grid->npcol + j ) /* Process number at coord(i,j) */
00170 #define CEILING(a,b)    ( ((a)%(b)) ? ((a)/(b) + 1) : ((a)/(b)) )
00171     /* For triangular solves */
00172 #define RHS_ITERATE(i)                    \
00173         for (i = 0; i < nrhs; ++i)
00174 #define X_BLK(i)                          \
00175         ilsum[i] * nrhs + (i+1) * XK_H
00176 #define LSUM_BLK(i)                       \
00177         ilsum[i] * nrhs + (i+1) * LSUM_H
00178 
00179 #define SuperLU_timer_  SuperLU_timer_dist_
00180 #define LOG2(x)   (log10((double) x) / log10(2.0))
00181 
00182 
00183 #if ( VAMPIR>=1 ) 
00184 #define VT_TRACEON    VT_traceon()
00185 #define VT_TRACEOFF   VT_traceoff()
00186 #else
00187 #define VT_TRACEON 
00188 #define VT_TRACEOFF
00189 #endif
00190 
00191 
00192 /***********************************************************************
00193  * New data types
00194  ***********************************************************************/
00195 
00196 /* 
00197  *   Define the 2D mapping of matrix blocks to process grid.
00198  *
00199  *   Process grid:
00200  *     Processes are numbered (0 : P-1).
00201  *     P = Pr x Pc, where Pr, Pc are the number of process rows and columns.
00202  *     (pr,pc) is the coordinate of IAM; 0 <= pr < Pr, 0 <= pc < Pc.
00203  *
00204  *   Matrix blocks:
00205  *     Matrix is partitioned according to supernode partitions, both
00206  *     column and row-wise. 
00207  *     The k-th block columns (rows) contains columns (rows) (s:t), where
00208  *             s=xsup[k], t=xsup[k+1]-1.
00209  *     Block A(I,J) contains
00210  *             rows from (xsup[I]:xsup[I+1]-1) and
00211  *             columns from (xsup[J]:xsup[J+1]-1)
00212  *
00213  *  Mapping of matrix entry (i,j) to matrix block (I,J):
00214  *     (I,J) = ( supno[i], supno[j] )
00215  *
00216  *  Mapping of matrix block (I,J) to process grid (pr,pc):
00217  *     (pr,pc) = ( MOD(I,NPROW), MOD(J,NPCOL) )
00218  *  
00219  *  (xsup[nsupers],supno[n]) are replicated on all processors.
00220  *
00221  */
00222 
00223 /*-- Communication subgroup */
00224 typedef struct {
00225     MPI_Comm comm;        /* MPI communicator */
00226     int Np;               /* number of processes */
00227     int Iam;              /* my process number */
00228 } superlu_scope_t;
00229 
00230 /*-- Process grid definition */
00231 typedef struct {
00232     MPI_Comm comm;        /* MPI communicator */
00233     superlu_scope_t rscp; /* row scope */
00234     superlu_scope_t cscp; /* column scope */
00235     int iam;              /* my process number in this scope */
00236     int_t nprow;          /* number of process rows */
00237     int_t npcol;          /* number of process columns */
00238 } gridinfo_t;
00239 
00240 
00241 /*
00242  *-- The structures are determined by SYMBFACT and used thereafter.
00243  *
00244  * (xsup,supno) describes mapping between supernode and column:
00245  *      xsup[s] is the leading column of the s-th supernode.
00246  *      supno[i] is the supernode no to which column i belongs;
00247  *      e.g.   supno 0 1 2 2 3 3 3 4 4 4 4 4   (n=12)
00248  *              xsup 0 1 2 4 7 12
00249  *      Note: dfs will be performed on supernode rep. relative to the new 
00250  *            row pivoting ordering
00251  *
00252  * This is allocated during symbolic factorization SYMBFACT.
00253  */
00254 typedef struct {
00255     int_t     *xsup;
00256     int_t     *supno;
00257 } Glu_persist_t;
00258 
00259 /*
00260  *-- The structures are determined by SYMBFACT and used by DDISTRIBUTE.
00261  * 
00262  * (xlsub,lsub): lsub[*] contains the compressed subscript of
00263  *      rectangular supernodes; xlsub[j] points to the starting
00264  *      location of the j-th column in lsub[*]. Note that xlsub 
00265  *      is indexed by column.
00266  *      Storage: original row subscripts
00267  *
00268  *      During the course of sparse LU factorization, we also use
00269  *      (xlsub,lsub) for the purpose of symmetric pruning. For each
00270  *      supernode {s,s+1,...,t=s+r} with first column s and last
00271  *      column t, the subscript set
00272  *              lsub[j], j=xlsub[s], .., xlsub[s+1]-1
00273  *      is the structure of column s (i.e. structure of this supernode).
00274  *      It is used for the storage of numerical values.
00275  *      Furthermore,
00276  *              lsub[j], j=xlsub[t], .., xlsub[t+1]-1
00277  *      is the structure of the last column t of this supernode.
00278  *      It is for the purpose of symmetric pruning. Therefore, the
00279  *      structural subscripts can be rearranged without making physical
00280  *      interchanges among the numerical values.
00281  *
00282  *      However, if the supernode has only one column, then we
00283  *      only keep one set of subscripts. For any subscript interchange
00284  *      performed, similar interchange must be done on the numerical
00285  *      values.
00286  *
00287  *      The last column structures (for pruning) will be removed
00288  *      after the numercial LU factorization phase.
00289  *
00290  * (xusub,usub): xusub[i] points to the starting location of column i
00291  *      in usub[]. For each U-segment, only the row index of first nonzero
00292  *      is stored in usub[].
00293  *
00294  *      Each U column consists of a number of full segments. Each full segment
00295  *      starts from a leading nonzero, running up to the supernode (block)
00296  *      boundary. (Recall that the column-wise supernode partition is also
00297  *      imposed on the rows.) Because the segment is full, we don't store all
00298  *      the row indices. Instead, only the leading nonzero index is stored.
00299  *      The rest can be found together with xsup/supno pair.
00300  *      For example, 
00301  *          usub[xsub[j+1]] - usub[xsub[j]] = number of segments in column j.
00302  *          for any i in usub[], 
00303  *              supno[i]         = block number in which i belongs to
00304  *              xsup[supno[i]+1] = first row of the next block
00305  *              The nonzeros of this segment are: 
00306  *                  i, i+1 ... xsup[supno[i]+1]-1 (only i is stored in usub[])
00307  *
00308  */
00309 typedef struct {
00310     int_t     *lsub;     /* compressed L subscripts */
00311     int_t     *xlsub;
00312     int_t     *usub;     /* compressed U subscripts */
00313     int_t     *xusub;
00314     int_t     nzlmax;    /* current max size of lsub */
00315     int_t     nzumax;    /*    "    "    "      usub */
00316     LU_space_t MemModel; /* 0 - system malloc'd; 1 - user provided */
00317 } Glu_freeable_t;
00318 
00319 
00320 /* 
00321  *-- The structure used to store matrix A of the linear system and
00322  *   several vectors describing the transformations done to matrix A.
00323  *
00324  * A      (SuperMatrix*)
00325  *        Matrix A in A*X=B, of dimension (A->nrow, A->ncol).
00326  *        The number of linear equations is A->nrow. The type of A can be:
00327  *        Stype = SLU_NC; Dtype = SLU_D; Mtype = SLU_GE.
00328  *         
00329  * DiagScale  (DiagScale_t)
00330  *        Specifies the form of equilibration that was done.
00331  *        = NOEQUIL: No equilibration.
00332  *        = ROW:  Row equilibration, i.e., A was premultiplied by diag(R).
00333  *        = COL:  Column equilibration, i.e., A was postmultiplied by diag(C).
00334  *        = BOTH: Both row and column equilibration, i.e., A was replaced 
00335  *                 by diag(R)*A*diag(C).
00336  *
00337  * R      double*, dimension (A->nrow)
00338  *        The row scale factors for A.
00339  *        If DiagScale = ROW or BOTH, A is multiplied on the left by diag(R).
00340  *        If DiagScale = NOEQUIL or COL, R is not defined.
00341  *
00342  * C      double*, dimension (A->ncol)
00343  *        The column scale factors for A.
00344  *        If DiagScale = COL or BOTH, A is multiplied on the right by diag(C).
00345  *        If DiagScale = NOEQUIL or ROW, C is not defined.
00346  *         
00347  * perm_r (int*) dimension (A->nrow)
00348  *        Row permutation vector which defines the permutation matrix Pr,
00349  *        perm_r[i] = j means row i of A is in position j in Pr*A.
00350  *
00351  * perm_c (int*) dimension (A->ncol)
00352  *        Column permutation vector, which defines the 
00353  *        permutation matrix Pc; perm_c[i] = j means column i of A is 
00354  *        in position j in A*Pc.
00355  *
00356  */
00357 typedef struct {
00358     DiagScale_t DiagScale;
00359     double *R;
00360     double *C; 
00361     int_t  *perm_r;
00362     int_t  *perm_c;
00363 } ScalePermstruct_t;
00364 
00365 /* 
00366  *-- This contains the options used to control the solve process.
00367  *
00368  * Fact   (fact_t)
00369  *        Specifies whether or not the factored form of the matrix
00370  *        A is supplied on entry, and if not, how the matrix A should
00371  *        be factorizaed.
00372  *        = DOFACT: The matrix A will be factorized from scratch, and the
00373  *             factors will be stored in L and U.
00374  *        = SamePattern: The matrix A will be factorized assuming
00375  *             that a factorization of a matrix with the same sparsity
00376  *             pattern was performed prior to this one. Therefore, this
00377  *             factorization will reuse column permutation vector 
00378  *             ScalePermstruct->perm_c and the column elimination tree
00379  *             LUstruct->etree.
00380  *        = SamePattern_SameRowPerm: The matrix A will be factorized
00381  *             assuming that a factorization of a matrix with the same
00382  *             sparsity pattern and similar numerical values was performed
00383  *             prior to this one. Therefore, this factorization will reuse
00384  *             both row and column scaling factors R and C, and the
00385  *             both row and column permutation vectors perm_r and perm_c,
00386  *             distributed data structure set up from the previous symbolic
00387  *             factorization.
00388  *        = FACTORED: On entry, L, U, perm_r and perm_c contain the 
00389  *              factored form of A. If DiagScale is not NOEQUIL, the matrix
00390  *              A has been equilibrated with scaling factors R and C.
00391  *
00392  * Equil  (yes_no_t)
00393  *        Specifies whether to equilibrate the system (scale A's row and
00394  *        columns to have unit norm).
00395  *
00396  * ColPerm (colperm_t)
00397  *        Specifies what type of column permutation to use to reduce fill.
00398  *        = NATURAL: use the natural ordering 
00399  *        = MMD_ATA: use minimum degree ordering on structure of A'*A
00400  *        = MMD_AT_PLUS_A: use minimum degree ordering on structure of A'+A
00401  *        = MY_PERMC: use the ordering specified in ScalePermstruct->perm_c[]
00402  *         
00403  * Trans  (trans_t)
00404  *        Specifies the form of the system of equations:
00405  *        = NOTRANS: A * X = B        (No transpose)
00406  *        = TRANS:   A**T * X = B     (Transpose)
00407  *        = CONJ:    A**H * X = B     (Transpose)
00408  *
00409  * IterRefine (IterRefine_t)
00410  *        Specifies whether to perform iterative refinement.
00411  *        = NO: no iterative refinement
00412  *        = WorkingPrec: perform iterative refinement in working precision
00413  *        = ExtraPrec: perform iterative refinement in extra precision
00414  *
00415  * PrintStat (yes_no_t)
00416  *        Specifies whether to print the solver's statistics.
00417  *
00418  * DiagPivotThresh (double, in [0.0, 1.0]) (only for sequential SuperLU)
00419  *        Specifies the threshold used for a diagonal entry to be an
00420  *        acceptable pivot.
00421  *
00422  * RowPerm (rowperm_t) (only for SuperLU_DIST)
00423  *        Specifies whether to permute rows of the original matrix.
00424  *        = NO: not to permute the rows
00425  *        = LargeDiag: make the diagonal large relative to the off-diagonal
00426  *        = MY_PERMR: use the permutation given in ScalePermstruct->perm_r[]
00427  *           
00428  * ReplaceTinyPivot (yes_no_t) (only for SuperLU_DIST)
00429  *        Specifies whether to replace the tiny diagonals by
00430  *        sqrt(epsilon)*||A|| during LU factorization.
00431  *
00432  * SolveInitialized (yes_no_t) (only for SuperLU_DIST)
00433  *        Specifies whether the initialization has been performed to the
00434  *        triangular solve.
00435  *
00436  * RefineInitialized (yes_no_t) (only for SuperLU_DIST)
00437  *        Specifies whether the initialization has been performed to the
00438  *        sparse matrix-vector multiplication routine needed in iterative
00439  *        refinement.
00440  */
00441 typedef struct {
00442     fact_t        Fact;
00443     yes_no_t      Equil;
00444     yes_no_t      ParSymbFact;
00445     colperm_t     ColPerm;
00446     rowperm_t     RowPerm;
00447     double        DiagPivotThresh;
00448     IterRefine_t  IterRefine;
00449     trans_t       Trans;
00450     yes_no_t      ReplaceTinyPivot;
00451     yes_no_t      SolveInitialized;
00452     yes_no_t      RefineInitialized;
00453     yes_no_t      PrintStat;
00454 } superlu_options_t;
00455 
00456 typedef struct {
00457     float for_lu;
00458     float total;
00459     int_t expansions;
00460 } mem_usage_t;
00461 
00462 
00463 /***********************************************************************
00464  * Function prototypes
00465  ***********************************************************************/
00466 
00467 #ifdef __cplusplus
00468 extern "C" {
00469 #endif
00470 
00471 extern void    set_default_options_dist(superlu_options_t *);
00472 extern void    print_options_dist(superlu_options_t *);
00473 extern void    Destroy_CompCol_Matrix_dist(SuperMatrix *);
00474 extern void    Destroy_SuperNode_Matrix_dist(SuperMatrix *);
00475 extern void    Destroy_SuperMatrix_Store_dist(SuperMatrix *);
00476 extern void    Destroy_CompCol_Permuted_dist(SuperMatrix *);
00477 extern void    Destroy_CompRowLoc_Matrix_dist(SuperMatrix *);
00478 extern void    Destroy_CompRow_Matrix_dist(SuperMatrix *);
00479 extern void    sp_colorder (superlu_options_t*, SuperMatrix*, int_t*, int_t*,
00480                             SuperMatrix*);
00481 extern int_t   sp_coletree_dist (int_t *, int_t *, int_t *, int_t, int_t,
00482                                  int_t *);
00483 extern void    countnz_dist (const int_t, int_t *, int_t *, int_t *,
00484                              Glu_persist_t *, Glu_freeable_t *);
00485 extern int_t   fixupL_dist (const int_t, const int_t *, Glu_persist_t *,
00486                             Glu_freeable_t *);
00487 extern int_t   *TreePostorder_dist (int_t, int_t *);
00488 extern float   slamch_(char *);
00489 extern double  dlamch_(char *);
00490 extern void    *superlu_malloc_dist (size_t);
00491 extern void    superlu_free_dist (void*);
00492 extern int_t   *intMalloc_dist (int_t);
00493 extern int_t   *intCalloc_dist (int_t);
00494 
00495 /* Auxiliary routines */
00496 extern double  SuperLU_timer_ ();
00497 extern void    superlu_abort_and_exit_dist(char *);
00498 extern int_t   sp_ienv_dist (int_t);
00499 extern int     lsame_ (char *, char *);
00500 extern int     xerbla_ (char *, int *);
00501 extern void    ifill_dist (int_t *, int_t, int_t);
00502 extern void    super_stats_dist (int_t, int_t *);
00503 extern void    ScalePermstructInit(const int_t, const int_t, 
00504                                    ScalePermstruct_t *);
00505 extern void    ScalePermstructFree(ScalePermstruct_t *);
00506 extern void  superlu_gridinit(MPI_Comm, int_t, int_t, gridinfo_t *);
00507 extern void  superlu_gridmap(MPI_Comm, int_t, int_t, int_t [], int_t,
00508                              gridinfo_t *);
00509 extern void  superlu_gridexit(gridinfo_t *);
00510 extern void  get_perm_c_dist(int_t, int_t, SuperMatrix *, int_t *);
00511 extern void  a_plus_at_dist(const int_t, const int_t, int_t *, int_t *,
00512                             int_t *, int_t **, int_t **);
00513 extern void  bcast_tree(void *, int, MPI_Datatype, int, int,
00514                         gridinfo_t *, int, int *);
00515 extern int_t symbfact(superlu_options_t *, int, SuperMatrix *, int_t *,
00516                       int_t *, Glu_persist_t *, Glu_freeable_t *);
00517 extern int_t symbfact_SubInit(fact_t, void *, int_t, int_t, int_t, int_t,
00518                               Glu_persist_t *, Glu_freeable_t *);
00519 extern int_t symbfact_SubXpand(int_t, int_t, int_t, MemType, int_t *,
00520                                Glu_freeable_t *);
00521 extern int_t symbfact_SubFree(Glu_freeable_t *);
00522 extern void  get_diag_procs(int_t, Glu_persist_t *, gridinfo_t *, int_t *,
00523                             int_t **, int_t **);
00524 extern int_t QuerySpace_dist(int_t, int_t, Glu_freeable_t *, mem_usage_t *);
00525 extern int   xerbla_ (char *, int *);
00526 extern void  pxerbla (char *, gridinfo_t *, int_t);
00527 extern void  PStatInit(SuperLUStat_t *);
00528 extern void  PStatFree(SuperLUStat_t *);
00529 extern void  PStatPrint(superlu_options_t *, SuperLUStat_t *, gridinfo_t *);
00530 
00531 
00532 /* Prototypes for parallel symbolic factorization */
00533 extern float symbfact_dist
00534 (int,  int, SuperMatrix *, int_t *, int_t *,  int_t *, int_t *,
00535  Pslu_freeable_t *, MPI_Comm *, MPI_Comm *,  mem_usage_t *);
00536 
00537 /* Get the column permutation using parmetis */
00538 extern float get_perm_c_parmetis 
00539 (SuperMatrix *, int_t *, int_t *, int, int, 
00540  int_t **, int_t **, gridinfo_t *, MPI_Comm *);
00541 
00542 /* Auxiliary routines for memory expansions used during
00543    the parallel symbolic factorization routine */
00544 
00545 extern int_t psymbfact_LUXpandMem
00546 (int_t, int_t, int_t, int_t, int_t, int_t, int_t, int_t, 
00547  Pslu_freeable_t *, Llu_symbfact_t *,  vtcsInfo_symbfact_t *, psymbfact_stat_t *);
00548 
00549 extern int_t psymbfact_LUXpand
00550 (int_t, int_t, int_t, int_t, int_t *, int_t, int_t, int_t, int_t, 
00551  Pslu_freeable_t *, Llu_symbfact_t *,  vtcsInfo_symbfact_t *, psymbfact_stat_t *);
00552 
00553 extern int_t psymbfact_LUXpand_RL
00554 (int_t, int_t, int_t, int_t, int_t, int_t,
00555  Pslu_freeable_t *, Llu_symbfact_t *, vtcsInfo_symbfact_t *, psymbfact_stat_t *);
00556 
00557 extern int_t psymbfact_prLUXpand
00558 (int_t,  int_t,
00559  MemType, Llu_symbfact_t *, psymbfact_stat_t *);
00560 
00561 /* Routines for debugging */
00562 extern void  print_panel_seg_dist(int_t, int_t, int_t, int_t, int_t *, int_t *);
00563 extern void  check_repfnz_dist(int_t, int_t, int_t, int_t *);
00564 extern int_t CheckZeroDiagonal(int_t, int_t *, int_t *, int_t *);
00565 extern void  PrintDouble5(char *, int_t, double *);
00566 extern void  PrintInt10(char *, int_t, int_t *);
00567 extern int   file_PrintInt10(FILE *, char *, int_t, int_t *);
00568 
00569 #ifdef __cplusplus
00570   }
00571 #endif
00572 
00573 #endif /* __SUPERLU_DEFS */

Generated on Sat Aug 9 23:23:51 2008 for SuperLUDistributed by  doxygen 1.4.6