void
pdgsrfs_ABXglobal(int_t n, SuperMatrix *A, double anorm, LUstruct_t *LUstruct,
gridinfo_t *grid, double *B, int_t ldb, double *X, int_t ldx,
int nrhs, double *berr, SuperLUStat_t *stat, int *info)
{
#define ITMAX 20
Glu_persist_t *Glu_persist = LUstruct->Glu_persist;
LocalLU_t *Llu = LUstruct->Llu;
/*
* Data structures used by matrix-vector multiply routine.
*/
int_t N_update; /* Number of variables updated on this process */
int_t *update; /* vector elements (global index) updated
on this processor. */
int_t *bindx;
double *val;
int_t *mv_sup_to_proc; /* Supernode to process mapping in
matrix-vector multiply. */
/*-- end data structures for matrix-vector multiply --*/
double *b, *ax, *R, *B_col, *temp, *work, *X_col,
*x_trs, *dx_trs;
int_t count, ii, j, jj, k, knsupc, lk, lwork,
nprow, nsupers, nz, p;
int i, iam, pkk;
int_t *ilsum, *xsup;
double eps, lstres;
double s, safmin, safe1, safe2;
/* NEW STUFF */
int_t num_diag_procs, *diag_procs; /* Record diagonal process numbers. */
int_t *diag_len; /* Length of the X vector on diagonal processes. */
/*-- Function prototypes --*/
extern void pdgstrs1(int_t, LUstruct_t *, gridinfo_t *,
double *, int, SuperLUStat_t *, int *);
/* Test the input parameters. */
*info = 0;
if ( n < 0 ) *info = -1;
else if ( A->nrow != A->ncol || A->nrow < 0 ||
A->Stype != SLU_NCP || A->Dtype != SLU_D || A->Mtype != SLU_GE )
*info = -2;
else if ( ldb < SUPERLU_MAX(0, n) ) *info = -10;
else if ( ldx < SUPERLU_MAX(0, n) ) *info = -12;
else if ( nrhs < 0 ) *info = -13;
if (*info != 0) {
i = -(*info);
pxerr_dist("pdgsrfs_ABXglobal", grid, i);
return;
}
/* Quick return if possible. */
if ( n == 0 || nrhs == 0 ) {
return;
}
/* Initialization. */
iam = grid->iam;
nprow = grid->nprow;
nsupers = Glu_persist->supno[n-1] + 1;
xsup = Glu_persist->xsup;
ilsum = Llu->ilsum;
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Enter pdgsrfs_ABXglobal()");
#endif
get_diag_procs(n, Glu_persist, grid, &num_diag_procs,
&diag_procs, &diag_len);
#if ( PRNTlevel>=1 )
if ( !iam ) {
printf(".. number of diag processes = " IFMT "\n", num_diag_procs);
PrintInt10("diag_procs", num_diag_procs, diag_procs);
PrintInt10("diag_len", num_diag_procs, diag_len);
}
#endif
if ( !(mv_sup_to_proc = intCalloc_dist(nsupers)) )
ABORT("Calloc fails for mv_sup_to_proc[]");
pdgsmv_AXglobal_setup(A, Glu_persist, grid, &N_update, &update,
&val, &bindx, mv_sup_to_proc);
i = CEILING( nsupers, nprow ); /* Number of local block rows */
ii = Llu->ldalsum + i * XK_H;
k = SUPERLU_MAX(N_update, sp_ienv_dist(3));
jj = diag_len[0];
for (j = 1; j < num_diag_procs; ++j) jj = SUPERLU_MAX( jj, diag_len[j] );
jj = SUPERLU_MAX( jj, N_update );
lwork = N_update /* For ax and R */
+ ii /* For dx_trs */
+ ii /* For x_trs */
+ k /* For b */
+ jj; /* for temp */
if ( !(work = doubleMalloc_dist(lwork)) )
ABORT("Malloc fails for work[]");
ax = R = work;
dx_trs = work + N_update;
x_trs = dx_trs + ii;
b = x_trs + ii;
temp = b + k;
#if ( DEBUGlevel>=2 )
{
double *dwork = doubleMalloc_dist(n);
for (i = 0; i < n; ++i) {
if ( i & 1 ) dwork[i] = 1.;
else dwork[i] = 2.;
}
/* Check correctness of matrix-vector multiply. */
pdgsmv_AXglobal(N_update, update, val, bindx, dwork, ax);
PrintDouble5("Mult A*x", N_update, ax);
SUPERLU_FREE(dwork);
}
#endif
/* NZ = maximum number of nonzero elements in each row of A, plus 1 */
nz = A->ncol + 1;
eps = dmach_dist("Epsilon");
safmin = dmach_dist("Safe minimum");
/* Set SAFE1 essentially to be the underflow threshold times the
number of additions in each row. */
safe1 = nz * safmin;
safe2 = safe1 / eps;
#if ( DEBUGlevel>=1 )
if ( !iam ) printf(".. eps = %e\tanorm = %e\tsafe1 = %e\tsafe2 = %e\n",
eps, anorm, safe1, safe2);
#endif
/* Do for each right-hand side ... */
for (j = 0; j < nrhs; ++j) {
count = 0;
lstres = 3.;
/* Copy X into x on the diagonal processes. */
B_col = &B[j*ldb];
X_col = &X[j*ldx];
for (p = 0; p < num_diag_procs; ++p) {
pkk = diag_procs[p];
if ( iam == pkk ) {
for (k = p; k < nsupers; k += num_diag_procs) {
knsupc = SuperSize( k );
lk = LBi( k, grid );
ii = ilsum[lk] + (lk+1)*XK_H;
jj = FstBlockC( k );
for (i = 0; i < knsupc; ++i) x_trs[i+ii] = X_col[i+jj];
dx_trs[ii-XK_H] = k;/* Block number prepended in header. */
}
}
}
/* Copy B into b distributed the same way as matrix-vector product. */
if ( N_update ) ii = update[0];
for (i = 0; i < N_update; ++i) b[i] = B_col[i + ii];
while (1) { /* Loop until stopping criterion is satisfied. */
/* Compute residual R = B - op(A) * X,
where op(A) = A, A**T, or A**H, depending on TRANS. */
/* Matrix-vector multiply. */
pdgsmv_AXglobal(N_update, update, val, bindx, X_col, ax);
/* Compute residual. */
for (i = 0; i < N_update; ++i) R[i] = b[i] - ax[i];
/* Compute abs(op(A))*abs(X) + abs(B). */
pdgsmv_AXglobal_abs(N_update, update, val, bindx, X_col, temp);
for (i = 0; i < N_update; ++i) temp[i] += fabs(b[i]);
s = 0.0;
for (i = 0; i < N_update; ++i) {
if ( temp[i] > safe2 ) {
s = SUPERLU_MAX(s, fabs(R[i]) / temp[i]);
} else if ( temp[i] != 0.0 ) {
/* Adding SAFE1 to the numerator guards against
spuriously zero residuals (underflow). */
s = SUPERLU_MAX(s, (safe1 + fabs(R[i])) / temp[i]);
}
/* If temp[i] is exactly 0.0 (computed by PxGSMV), then
we know the true residual also must be exactly 0.0. */
}
MPI_Allreduce( &s, &berr[j], 1, MPI_DOUBLE, MPI_MAX, grid->comm );
#if ( PRNTlevel>= 1 )
if ( !iam )
printf("(%2d) .. Step " IFMT ": berr[j] = %e\n", iam, count, berr[j]);
#endif
if ( berr[j] > eps && berr[j] * 2 <= lstres && count < ITMAX ) {
/* Compute new dx. */
redist_all_to_diag(n, R, Glu_persist, Llu, grid,
mv_sup_to_proc, dx_trs);
pdgstrs1(n, LUstruct, grid, dx_trs, 1, stat, info);
/* Update solution. */
for (p = 0; p < num_diag_procs; ++p)
if ( iam == diag_procs[p] )
for (k = p; k < nsupers; k += num_diag_procs) {
lk = LBi( k, grid );
ii = ilsum[lk] + (lk+1)*XK_H;
knsupc = SuperSize( k );
for (i = 0; i < knsupc; ++i)
x_trs[i + ii] += dx_trs[i + ii];
}
lstres = berr[j];
++count;
/* Transfer x_trs (on diagonal processes) into X
(on all processes). */
gather_1rhs_diag_to_all(n, x_trs, Glu_persist, Llu, grid,
num_diag_procs, diag_procs, diag_len,
X_col, temp);
} else {
break;
}
} /* end while */
stat->RefineSteps = count;
} /* for j ... */
/* Deallocate storage used by matrix-vector multiplication. */
SUPERLU_FREE(diag_procs);
SUPERLU_FREE(diag_len);
if ( N_update ) {
SUPERLU_FREE(update);
SUPERLU_FREE(bindx);
SUPERLU_FREE(val);
}
SUPERLU_FREE(mv_sup_to_proc);
SUPERLU_FREE(work);
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Exit pdgsrfs_ABXglobal()");
#endif
} /* PDGSRFS_ABXGLOBAL */
/*! \brief
<pre>
Purpose
=======
DLAQGS_dist equilibrates a general sparse M by N matrix A using the row
and column scaling factors in the vectors R and C.
See supermatrix.h for the definition of 'SuperMatrix' structure.
Arguments
=========
A (input/output) SuperMatrix*
On exit, the equilibrated matrix. See EQUED for the form of
the equilibrated matrix. The type of A can be:
Stype = SLU_NC; Dtype = SLU_D; Mtype = SLU_GE.
R (input) double*, dimension (A->nrow)
The row scale factors for A.
C (input) double*, dimension (A->ncol)
The column scale factors for A.
ROWCND (input) double
Ratio of the smallest R(i) to the largest R(i).
COLCND (input) double
Ratio of the smallest C(i) to the largest C(i).
AMAX (input) double
Absolute value of largest matrix entry.
EQUED (output) char*
Specifies the form of equilibration that was done.
= 'N': No equilibration
= 'R': Row equilibration, i.e., A has been premultiplied by
diag(R).
= 'C': Column equilibration, i.e., A has been postmultiplied
by diag(C).
= 'B': Both row and column equilibration, i.e., A has been
replaced by diag(R) * A * diag(C).
Internal Parameters
===================
THRESH is a threshold value used to decide if row or column scaling
should be done based on the ratio of the row or column scaling
factors. If ROWCND < THRESH, row scaling is done, and if
COLCND < THRESH, column scaling is done.
LARGE and SMALL are threshold values used to decide if row scaling
should be done based on the absolute size of the largest matrix
element. If AMAX > LARGE or AMAX < SMALL, row scaling is done.
=====================================================================
</pre>
*/
void
dlaqgs_dist(SuperMatrix *A, double *r, double *c,
double rowcnd, double colcnd, double amax, char *equed)
{
#define THRESH (0.1)
/* Local variables */
NCformat *Astore;
double *Aval;
int_t i, j, irow;
double large, small, cj;
/* Quick return if possible */
if (A->nrow <= 0 || A->ncol <= 0) {
*(unsigned char *)equed = 'N';
return;
}
Astore = (NCformat *) A->Store;
Aval = (double *) Astore->nzval;
/* Initialize LARGE and SMALL. */
small = dmach_dist("Safe minimum") / dmach_dist("Precision");
large = 1. / small;
if (rowcnd >= THRESH && amax >= small && amax <= large) {
if (colcnd >= THRESH)
*(unsigned char *)equed = 'N';
else {
/* Column scaling */
for (j = 0; j < A->ncol; ++j) {
cj = c[j];
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
Aval[i] *= cj;
}
}
*(unsigned char *)equed = 'C';
}
} else if (colcnd >= THRESH) {
/* Row scaling, no column scaling */
for (j = 0; j < A->ncol; ++j)
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
irow = Astore->rowind[i];
Aval[i] *= r[irow];
}
*(unsigned char *)equed = 'R';
} else {
/* Row and column scaling */
for (j = 0; j < A->ncol; ++j) {
cj = c[j];
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
irow = Astore->rowind[i];
Aval[i] *= cj * r[irow];
}
}
*(unsigned char *)equed = 'B';
}
return;
} /* dlaqgs_dist */