void Solve()
{
int flag;
MPI_Initialized(&flag);
if (flag == 0)
return;
MPI_Comm_size(MPI_COMM_WORLD, &Size);
MPI_Comm_rank(MPI_COMM_WORLD, &Rank);
ParallelInit();
ParallelCalc();
ParallelOutputRes();
}
pdgstrf_threadarg_t *
pdgstrf_thread_init(SuperMatrix *A, SuperMatrix *L, SuperMatrix *U,
pdgstrf_options_t *pdgstrf_options,
pxgstrf_shared_t *pxgstrf_shared,
Gstat_t *Gstat, int *info)
{
/*
* -- SuperLU MT routine (version 1.0) --
* Univ. of California Berkeley, Xerox Palo Alto Research Center,
* and Lawrence Berkeley National Lab.
* August 15, 1997
*
* Purpose
* =======
*
* pdgstrf_thread_init() initializes the parallel data structures
* for the multithreaded routine pdgstrf_thread().
*
* Arguments
* =========
*
* A (input) SuperMatrix*
* Original matrix A, permutated by columns, of dimension
* (A->nrow, A->ncol). The type of A can be:
* Stype = NCP; Dtype = _D; Mtype = GE.
*
* L (input) SuperMatrix*
* If pdgstrf_options->refact = YES, then use the existing
* storage in L to perform LU factorization;
* Otherwise, L is not accessed. L has types:
* Stype = SCP, Dtype = _D, Mtype = TRLU.
*
* U (input) SuperMatrix*
* If pdgstrf_options->refact = YES, then use the existing
* storage in U to perform LU factorization;
* Otherwise, U is not accessed. U has types:
* Stype = NCP, Dtype = _D, Mtype = TRU.
*
* pdgstrf_options (input) pdgstrf_options_t*
* The structure contains the parameters to control how the
* factorization is performed;
* See pdgstrf_options_t structure defined in pdsp_defs.h.
*
* pxgstrf_shared (output) pxgstrf_shared_t*
* The structure contains the shared task queue and the
* synchronization variables for parallel factorization.
* See pxgstrf_shared_t structure defined in pdsp_defs.h.
*
* Gstat (output) Gstat_t*
* Record all the statistics about the factorization;
* See Gstat_t structure defined in util.h.
*
* info (output) int*
* = 0: successful exit
* > 0: if pdgstrf_options->lwork = -1, info returns the estimated
* amount of memory (in bytes) required;
* Otherwise, it returns the number of bytes allocated when
* memory allocation failure occurred, plus A->ncol.
*
*/
static GlobalLU_t Glu; /* persistent to support repeated factors. */
pdgstrf_threadarg_t *pdgstrf_threadarg;
register int n, i, nprocs;
NCPformat *Astore;
int *perm_c;
int *perm_r;
int *inv_perm_c; /* inverse of perm_c */
int *inv_perm_r; /* inverse of perm_r */
int *xprune; /* points to locations in subscript vector lsub[*].
For column i, xprune[i] denotes the point where
structural pruning begins.
I.e. only xlsub[i],..,xprune[i]-1 need to be
traversed for symbolic factorization. */
int *ispruned;/* flag to indicate whether column j is pruned */
int nzlumax;
pxgstrf_relax_t *pxgstrf_relax;
nprocs = pdgstrf_options->nprocs;
perm_c = pdgstrf_options->perm_c;
perm_r = pdgstrf_options->perm_r;
n = A->ncol;
Astore = A->Store;
inv_perm_r = (int *) intMalloc(n);
inv_perm_c = (int *) intMalloc(n);
xprune = (int *) intMalloc(n);
ispruned = (int *) intCalloc(n);
/* Pack shared data objects to each process. */
pxgstrf_shared->inv_perm_r = inv_perm_r;
pxgstrf_shared->inv_perm_c = inv_perm_c;
pxgstrf_shared->xprune = xprune;
pxgstrf_shared->ispruned = ispruned;
pxgstrf_shared->A = A;
pxgstrf_shared->Glu = &Glu;
pxgstrf_shared->Gstat = Gstat;
pxgstrf_shared->info = info;
if ( pdgstrf_options->usepr ) {
/* Compute the inverse of perm_r */
for (i = 0; i < n; ++i) inv_perm_r[perm_r[i]] = i;
}
for (i = 0; i < n; ++i) inv_perm_c[perm_c[i]] = i;
/* Initialization. */
Glu.nsuper = -1;
Glu.nextl = 0;
Glu.nextu = 0;
Glu.nextlu = 0;
ifill(perm_r, n, EMPTY);
/* Identify relaxed supernodes at the bottom of the etree. */
pxgstrf_relax = (pxgstrf_relax_t *)
SUPERLU_MALLOC((n+2) * sizeof(pxgstrf_relax_t));
pxgstrf_relax_snode(n, pdgstrf_options, pxgstrf_relax);
/* Initialize mutex variables, task queue, determine panels. */
ParallelInit(n, pxgstrf_relax, pdgstrf_options, pxgstrf_shared);
/* Set up memory image in lusup[*]. */
nzlumax = PresetMap(n, A, pxgstrf_relax, pdgstrf_options, &Glu);
if ( pdgstrf_options->refact == NO ) Glu.nzlumax = nzlumax;
SUPERLU_FREE (pxgstrf_relax);
/* Allocate global storage common to all the factor routines */
*info = pdgstrf_MemInit(n, Astore->nnz, pdgstrf_options, L, U, &Glu);
if ( *info ) return NULL;
/* Prepare arguments to all threads. */
pdgstrf_threadarg = (pdgstrf_threadarg_t *)
SUPERLU_MALLOC(nprocs * sizeof(pdgstrf_threadarg_t));
for (i = 0; i < nprocs; ++i) {
pdgstrf_threadarg[i].pnum = i;
pdgstrf_threadarg[i].info = 0;
pdgstrf_threadarg[i].pdgstrf_options = pdgstrf_options;
pdgstrf_threadarg[i].pxgstrf_shared = pxgstrf_shared;
}
#if ( DEBUGlevel==1 )
printf("** pdgstrf_thread_init() called\n");
#endif
return (pdgstrf_threadarg);
}
