SRC/pzsymbfact_distdata.c File Reference

Redistribute the symbolic structure of L and U from the distribution. More...

#include <limits.h>
#include "superlu_zdefs.h"
#include "psymbfact.h"

Functions/Subroutines

static float dist_symbLU (int_t n, Pslu_freeable_t *Pslu_freeable, Glu_persist_t *Glu_persist, int_t **p_xlsub, int_t **p_lsub, int_t **p_xusub, int_t **p_usub, gridinfo_t *grid)
static float zdist_A (SuperMatrix *A, ScalePermstruct_t *ScalePermstruct, Glu_persist_t *Glu_persist, gridinfo_t *grid, int_t **p_ainf_colptr, int_t **p_ainf_rowind, doublecomplex **p_ainf_val, int_t **p_asup_rowptr, int_t **p_asup_colind, doublecomplex **p_asup_val, int_t *ilsum_i, int_t *ilsum_j)
float zdist_psymbtonum (fact_t fact, int_t n, SuperMatrix *A, ScalePermstruct_t *ScalePermstruct, Pslu_freeable_t *Pslu_freeable, LUstruct_t *LUstruct, gridinfo_t *grid)


Detailed Description

 -- Parallel symbolic factorization auxialiary routine (version 2.3) --
 -- Distributes the data from parallel symbolic factorization 
 -- to numeric factorization
 INRIA France -  July 1, 2004
 Laura Grigori

 November 1, 2007
 Feburary 20, 2008
 October 15, 2008
 

Function Documentation

static float dist_symbLU ( int_t  n,
Pslu_freeable_t Pslu_freeable,
Glu_persist_t Glu_persist,
int_t **  p_xlsub,
int_t **  p_lsub,
int_t **  p_xusub,
int_t **  p_usub,
gridinfo_t grid 
) [static]

 Purpose
 =======

 Redistribute the symbolic structure of L and U from the distribution
 used in the parallel symbolic factorization step to the distdibution
 used in the parallel numeric factorization step.  On exit, the L and U
 structure for the 2D distribution used in the numeric factorization step is
 stored in p_xlsub, p_lsub, p_xusub, p_usub.  The global supernodal 
 information is also computed and it is stored in Glu_persist->supno
 and Glu_persist->xsup.

 This routine allocates memory for storing the structure of L and U
 and the supernodes information.  This represents the arrays:
 p_xlsub, p_lsub, p_xusub, p_usub,
 Glu_persist->supno,  Glu_persist->xsup.

 This routine also deallocates memory allocated during symbolic 
 factorization routine.  That is, the folloing arrays are freed:
 Pslu_freeable->xlsub,  Pslu_freeable->lsub, 
 Pslu_freeable->xusub, Pslu_freeable->usub, 
 Pslu_freeable->globToLoc, Pslu_freeable->supno_loc, 
 Pslu_freeable->xsup_beg_loc, Pslu_freeable->xsup_end_loc.

 Arguments
 =========

 n      (Input) int_t
        Order of the input matrix
 Pslu_freeable  (Input) Pslu_freeable_t *
        Local L and U structure, 
        global to local indexing information.

 Glu_persist (Output) Glu_persist_t *
        Stores on output the information on supernodes mapping.

 p_xlsub (Output) int_t **
         Pointer to structure of L distributed on a 2D grid 
         of processors, stored by columns.

 p_lsub  (Output) int_t **
         Structure of L distributed on a 2D grid of processors, 
         stored by columns.

 p_xusub (Output) int_t **
         Pointer to structure of U distributed on a 2D grid 
         of processors, stored by rows.

 p_usub  (Output) int_t **
         Structure of U distributed on a 2D grid of processors, 
         stored by rows.

 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 in this routine when out of memory.
        (an approximation).
 

static float zdist_A ( SuperMatrix A,
ScalePermstruct_t ScalePermstruct,
Glu_persist_t Glu_persist,
gridinfo_t grid,
int_t **  p_ainf_colptr,
int_t **  p_ainf_rowind,
doublecomplex **  p_ainf_val,
int_t **  p_asup_rowptr,
int_t **  p_asup_colind,
doublecomplex **  p_asup_val,
int_t ilsum_i,
int_t ilsum_j 
) [static]

 Purpose
 =======
   Re-distribute A on the 2D process mesh.  The lower part is
   stored using a column format and the upper part
   is stored using a row format.

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

 ScalePermstruct (Input) ScalePermstruct_t*
        The data structure to store the scaling and permutation vectors
        describing the transformations performed to the original matrix A.

 Glu_persist  (Input) Glu_persist_t *
        Information on supernodes mapping.

 grid   (Input) gridinfo_t*
        The 2D process mesh.

 p_ainf_colptr (Output) int_t**
         Pointer to the lower part of A distributed on a 2D grid 
         of processors, stored by columns.

 p_ainf_rowind (Output) int_t**
         Structure of of the lower part of A distributed on a 
         2D grid of processors, stored by columns.

 p_ainf_val    (Output) doublecomplex**
         Numerical values of the lower part of A, distributed on a 
         2D grid of processors, stored by columns.

 p_asup_rowptr (Output) int_t**
         Pointer to the upper part of A distributed on a 2D grid 
         of processors, stored by rows.

 p_asup_colind (Output) int_t**
         Structure of of the upper part of A distributed on a 
         2D grid of processors, stored by rows.

 p_asup_val    (Output) doublecomplex**
         Numerical values of the upper part of A, distributed on a 
         2D grid of processors, stored by rows.

 ilsum_i  (Input) int_t *
       Starting position of each supernode in 
       the full array (local, block row wise).

 ilsum_j  (Input) int_t *
       Starting position of each supernode in 
       the full array (local, block column wise).

 Return value
 ============
   < 0, number of bytes allocated on return from the dist_symbLU
   > 0, number of bytes allocated when out of memory.
        (an approximation).
 

float zdist_psymbtonum ( fact_t  fact,
int_t  n,
SuperMatrix A,
ScalePermstruct_t ScalePermstruct,
Pslu_freeable_t Pslu_freeable,
LUstruct_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) ScalePermstruct_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) LUstruct_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).
 


Generated on Wed Nov 24 18:17:32 2010 for SuperLUDistributed by  doxygen 1.5.5