pdsymbfact_distdata.c File Reference
Redistribute the symbolic structure of L and U from the distribution. More...
Include dependency graph for pdsymbfact_distdata.c:
Functions | |
| static float | dist_symbLU (superlu_dist_options_t *options, 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 | ddist_A (SuperMatrix *A, dScalePermstruct_t *ScalePermstruct, Glu_persist_t *Glu_persist, gridinfo_t *grid, int_t **p_ainf_colptr, int_t **p_ainf_rowind, double **p_ainf_val, int_t **p_asup_rowptr, int_t **p_asup_colind, double **p_asup_val, int_t *ilsum_i, int_t *ilsum_j) |
| float | ddist_psymbtonum (superlu_dist_options_t *options, int_t n, SuperMatrix *A, dScalePermstruct_t *ScalePermstruct, Pslu_freeable_t *Pslu_freeable, dLUstruct_t *LUstruct, gridinfo_t *grid) |
Detailed Description
Redistribute the symbolic structure of L and U from the distribution.
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.
-- 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
◆ ddist_A()
|
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_D; Mtype = SLU_GE.
ScalePermstruct (Input) dScalePermstruct_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) double**
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) double**
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).
Here is the call graph for this function:
Here is the caller graph for this function:
◆ ddist_psymbtonum()
| float ddist_psymbtonum | ( | superlu_dist_options_t * | options, |
| int_t | n, | ||
| SuperMatrix * | A, | ||
| dScalePermstruct_t * | ScalePermstruct, | ||
| Pslu_freeable_t * | Pslu_freeable, | ||
| dLUstruct_t * | LUstruct, | ||
| gridinfo_t * | grid | ||
| ) |
Purpose
=======
Distribute the input matrix onto the 2D process mesh.
Arguments
=========
options (input) superlu_dist_options_t*
The structure defines the input parameters to control
how the LU decomposition and triangular solve are performed.
options->Fact specifies whether or not the L and U structures
will be re-used:
= SamePattern_SameRowPerm: L and U structures are input, and
unchanged on exit.
This routine should not be called for this case, an error
is generated. Instead, pddistribute routine should be called.
= DOFACT or SamePattern: L and U structures are computed and output.
n (Input) int
Dimension of the matrix.
A (Input) SuperMatrix*
The distributed input matrix A of dimension (A->nrow, A->ncol).
A may be overwritten by diag(R)*A*diag(C)*Pc^T.
The type of A can be: Stype = NR; Dtype = SLU_D; Mtype = GE.
ScalePermstruct (Input) dScalePermstruct_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) dLUstruct_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:
◆ dist_symbLU()
|
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
=========
options (input) superlu_dist_options_t*
The structure defines the input parameters to control
how the LU decomposition and triangular solve are performed.
n (Input) int_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).
Here is the call graph for this function:
Here is the caller graph for this function:
